[pointeurs] fonction renvoyant un ptr ou un tableau entier ?
9 réponses
David Noyelle
Bonjour a tous,
je me sers d'une fonction de manipulation de bits permettant de decoder les
differents champs de type unsigned char d'une adresse IP contenue dans une
variable de type unsigned long:
//affichage de l'IP
printf("IP lue = %d.%d.%d.%d", auch_ip[0], auch_ip[1], auch_ip[2],
auch_ip[3]);
}
***********************************************************
Juqu'ici tout va bien. Maintenant j'aimerai ecrire une fonction getIP(), qui
non seulement me decode l'IP contenue dans la variable de type unsigned
long, mais qui me renvoie l'addresse IP decodee.
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le tableau
auch_ip[] ?
2. Je pense que le plus simple est de faire en sorte que la fonction getIP()
renvoie un pointeur sur le premier element du tableau auch_ip[], mais j'ai
un petit peu de mal avec la syntaxe...
***********************************************************
??? getIP(unsigned long ul_ip)
{
unsigned char auch_ip[4];
//si la fonction getIP() renvoie un tableau
memcpy(auch_ip, getIP(ul_ip), 4); // correct ?
//si la fonction getIP() renvoie un pointeur
auch_ip = getIP(ul_ip); //correct ? utilisation de l'operateur & ?
}
***********************************************************
Merci pour vos lumieres, je sais que c'est une question classique sur
l'utilisation des pointeurs mais au debut c'est un peu troublant...
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Marc Boyer
David Noyelle <david_point_noyelle_chez_yahoo_point_fr> a écrit :
je me sers d'une fonction de manipulation de bits permettant de decoder les differents champs de type unsigned char d'une adresse IP contenue dans une variable de type unsigned long:
//affichage de l'IP printf("IP lue = %d.%d.%d.%d", auch_ip[0], auch_ip[1], auch_ip[2], auch_ip[3]); } *********************************************************** Juqu'ici tout va bien. Maintenant j'aimerai ecrire une fonction getIP(), qui non seulement me decode l'IP contenue dans la variable de type unsigned long, mais qui me renvoie l'addresse IP decodee.
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le tableau auch_ip[] ?
Le C ne permet pas de renvoyer un tableau, mais on peut renvoyer une structure contenant un tableau.
2. Je pense que le plus simple est de faire en sorte que la fonction getIP() renvoie un pointeur sur le premier element du tableau auch_ip[], mais j'ai un petit peu de mal avec la syntaxe...
Sauf que tu vas retourner un pointeur sur une variable locale, donc sur une variable qui n'existera plus. Pas très utile.
La façon idiomatique en C de faire remplir un tableau par une fonction est de passer à la fonction le dit tableau (en fait, un pointeur sur, grace à une conversion implicite).
La signature de la fonction devient void getIP(unsigned long ul_ip, unsigned char auch_ip[4]);
Marc Boyer -- À vélo, prendre une rue à contre-sens est moins dangereux que prendre un boulevard dans le sens légal. À qui la faute ?
David Noyelle <david_point_noyelle_chez_yahoo_point_fr> a écrit :
je me sers d'une fonction de manipulation de bits permettant de decoder les
differents champs de type unsigned char d'une adresse IP contenue dans une
variable de type unsigned long:
//affichage de l'IP
printf("IP lue = %d.%d.%d.%d", auch_ip[0], auch_ip[1], auch_ip[2],
auch_ip[3]);
}
***********************************************************
Juqu'ici tout va bien. Maintenant j'aimerai ecrire une fonction getIP(), qui
non seulement me decode l'IP contenue dans la variable de type unsigned
long, mais qui me renvoie l'addresse IP decodee.
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le tableau
auch_ip[] ?
Le C ne permet pas de renvoyer un tableau, mais on peut renvoyer
une structure contenant un tableau.
2. Je pense que le plus simple est de faire en sorte que la fonction getIP()
renvoie un pointeur sur le premier element du tableau auch_ip[], mais j'ai
un petit peu de mal avec la syntaxe...
Sauf que tu vas retourner un pointeur sur une variable locale, donc
sur une variable qui n'existera plus. Pas très utile.
La façon idiomatique en C de faire remplir un tableau par une
fonction est de passer à la fonction le dit tableau (en fait,
un pointeur sur, grace à une conversion implicite).
La signature de la fonction devient
void getIP(unsigned long ul_ip, unsigned char auch_ip[4]);
Marc Boyer
--
À vélo, prendre une rue à contre-sens est moins dangereux
que prendre un boulevard dans le sens légal. À qui la faute ?
David Noyelle <david_point_noyelle_chez_yahoo_point_fr> a écrit :
je me sers d'une fonction de manipulation de bits permettant de decoder les differents champs de type unsigned char d'une adresse IP contenue dans une variable de type unsigned long:
//affichage de l'IP printf("IP lue = %d.%d.%d.%d", auch_ip[0], auch_ip[1], auch_ip[2], auch_ip[3]); } *********************************************************** Juqu'ici tout va bien. Maintenant j'aimerai ecrire une fonction getIP(), qui non seulement me decode l'IP contenue dans la variable de type unsigned long, mais qui me renvoie l'addresse IP decodee.
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le tableau auch_ip[] ?
Le C ne permet pas de renvoyer un tableau, mais on peut renvoyer une structure contenant un tableau.
2. Je pense que le plus simple est de faire en sorte que la fonction getIP() renvoie un pointeur sur le premier element du tableau auch_ip[], mais j'ai un petit peu de mal avec la syntaxe...
Sauf que tu vas retourner un pointeur sur une variable locale, donc sur une variable qui n'existera plus. Pas très utile.
La façon idiomatique en C de faire remplir un tableau par une fonction est de passer à la fonction le dit tableau (en fait, un pointeur sur, grace à une conversion implicite).
La signature de la fonction devient void getIP(unsigned long ul_ip, unsigned char auch_ip[4]);
Marc Boyer -- À vélo, prendre une rue à contre-sens est moins dangereux que prendre un boulevard dans le sens légal. À qui la faute ?
David Noyelle
Bonjour,
merci pour la reponse.
2. Je pense que le plus simple est de faire en sorte que la fonction getIP()
renvoie un pointeur sur le premier element du tableau auch_ip[], mais j'ai
un petit peu de mal avec la syntaxe...
Sauf que tu vas retourner un pointeur sur une variable locale, donc sur une variable qui n'existera plus. Pas très utile.
Pourtant en ecrivant une fonction retournant un pointeur de tableau d'elements de type unsigned char, cela semble fonctionner:
*********************************************************** unsigned char (*getIP(unsigned long ul_ip))[] { unsigned char auch_ip[4];
//on obtient l'adresse (la variable est sensée ne plus exister...cependant il s'agit d'un env. embarqué) pauch_ip = getIP(ul_ip); printf("ip = %d.%d.%d.%d", pauch_ip[0], pauch_ip[1], pauch_ip[2]; pauch_ip[3]); }
*********************************************************** Remarque: la syntaxe suivante affiche l'IP a l'envers...
La façon idiomatique en C de faire remplir un tableau par une fonction est de passer à la fonction le dit tableau (en fait, un pointeur sur, grace à une conversion implicite).
La signature de la fonction devient void getIP(unsigned long ul_ip, unsigned char auch_ip[4]);
OK
David Noyelle david noyelle chez yahoo point fr
Bonjour,
merci pour la reponse.
2. Je pense que le plus simple est de faire en sorte que la fonction
getIP()
renvoie un pointeur sur le premier element du tableau auch_ip[], mais
j'ai
un petit peu de mal avec la syntaxe...
Sauf que tu vas retourner un pointeur sur une variable locale, donc
sur une variable qui n'existera plus. Pas très utile.
Pourtant en ecrivant une fonction retournant un pointeur de tableau
d'elements de type unsigned char, cela semble fonctionner:
***********************************************************
unsigned char (*getIP(unsigned long ul_ip))[]
{
unsigned char auch_ip[4];
//on obtient l'adresse (la variable est sensée ne plus exister...cependant
il s'agit d'un env. embarqué)
pauch_ip = getIP(ul_ip);
printf("ip = %d.%d.%d.%d", pauch_ip[0], pauch_ip[1], pauch_ip[2];
pauch_ip[3]);
}
***********************************************************
Remarque: la syntaxe suivante affiche l'IP a l'envers...
La façon idiomatique en C de faire remplir un tableau par une
fonction est de passer à la fonction le dit tableau (en fait,
un pointeur sur, grace à une conversion implicite).
La signature de la fonction devient
void getIP(unsigned long ul_ip, unsigned char auch_ip[4]);
//on obtient l'adresse (la variable est sensée ne plus exister...cependant il s'agit d'un env. embarqué) pauch_ip = getIP(ul_ip); printf("ip = %d.%d.%d.%d", pauch_ip[0], pauch_ip[1], pauch_ip[2]; pauch_ip[3]); }
*********************************************************** Remarque: la syntaxe suivante affiche l'IP a l'envers...
La façon idiomatique en C de faire remplir un tableau par une fonction est de passer à la fonction le dit tableau (en fait, un pointeur sur, grace à une conversion implicite).
La signature de la fonction devient void getIP(unsigned long ul_ip, unsigned char auch_ip[4]);
OK
David Noyelle david noyelle chez yahoo point fr
Marc Boyer
David Noyelle <david_point_noyelle_chez_yahoo_point_fr> a écrit :
2. Je pense que le plus simple est de faire en sorte que la fonction getIP()
renvoie un pointeur sur le premier element du tableau auch_ip[], mais j'ai
un petit peu de mal avec la syntaxe...
Sauf que tu vas retourner un pointeur sur une variable locale, donc sur une variable qui n'existera plus. Pas très utile.
Pourtant en ecrivant une fonction retournant un pointeur de tableau d'elements de type unsigned char, cela semble fonctionner:
Cela fait partie des programmes qui 'tombent en marche'. Il marche parce que l'espace mémoire ou existait ta variable locale n'a pas été ré-utilisé.
*********************************************************** Remarque: la syntaxe suivante affiche l'IP a l'envers...
Pb d'ordre d'évaluation de ++ je suppose. Essaye: printf("ip = %d.%d.%d.%d", pauch_ip, pauch_ip+1, pauch_ip+2, pauch_ip+3);
Marc Boyer -- À vélo, prendre une rue à contre-sens est moins dangereux que prendre un boulevard dans le sens légal. À qui la faute ?
Targeur fou
David Noyelle wrote:
Bonjour a tous,
Bonjour,
je me sers d'une fonction de manipulation de bits permettant de decoder l es differents champs de type unsigned char d'une adresse IP contenue dans une variable de type unsigned long:
Note : t'as ton byte réseau qui repose sur 8 bits, un octet, mais il faut savoir qu'en C, un char, signed char ou unsigned char fait CHAR_BIT bits de long (limits.h). Et les autres types intégraux ont des longueurs en bits multiples de celle de *char.
void printIP(unsigned long ul_ip) { unsigned char auch_ip[4];
Les fonctions non-standard (ntoh* et hton*, network to host et vice versa) ainsi que des masques ou macros d'extraction sont tout indiqués pour ce genre de travail.
//affichage de l'IP printf("IP lue = %d.%d.%d.%d", auch_ip[0], auch_ip[1], auch_ip[2], auch_ip[3]); } *********************************************************** Juqu'ici tout va bien. Maintenant j'aimerai ecrire une fonction getIP(), qui non seulement me decode l'IP contenue dans la variable de type unsigned long, mais qui me renvoie l'addresse IP decodee.
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le tableau auch_ip[] ?
Non.
2. Je pense que le plus simple est de faire en sorte que la fonction getI P() renvoie un pointeur sur le premier element du tableau auch_ip[], mais j'ai un petit peu de mal avec la syntaxe...
Pourquoi pas un pointeur en paramètre in-out plutôt qu'en retour, tu te compliques la vie.
*********************************************************** ??? getIP(unsigned long ul_ip)
je me sers d'une fonction de manipulation de bits permettant de decoder l es
differents champs de type unsigned char d'une adresse IP contenue dans une
variable de type unsigned long:
Note : t'as ton byte réseau qui repose sur 8 bits, un octet, mais il
faut savoir qu'en C, un char, signed char ou unsigned char fait
CHAR_BIT bits de long (limits.h). Et les autres types intégraux ont
des longueurs en bits multiples de celle de *char.
void printIP(unsigned long ul_ip)
{
unsigned char auch_ip[4];
Les fonctions non-standard (ntoh* et hton*, network to host et vice
versa) ainsi que des masques ou macros d'extraction sont tout indiqués
pour ce genre de travail.
//affichage de l'IP
printf("IP lue = %d.%d.%d.%d", auch_ip[0], auch_ip[1], auch_ip[2],
auch_ip[3]);
}
***********************************************************
Juqu'ici tout va bien. Maintenant j'aimerai ecrire une fonction getIP(), qui
non seulement me decode l'IP contenue dans la variable de type unsigned
long, mais qui me renvoie l'addresse IP decodee.
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le tableau
auch_ip[] ?
Non.
2. Je pense que le plus simple est de faire en sorte que la fonction getI P()
renvoie un pointeur sur le premier element du tableau auch_ip[], mais j'ai
un petit peu de mal avec la syntaxe...
Pourquoi pas un pointeur en paramètre in-out plutôt qu'en retour, tu
te compliques la vie.
***********************************************************
??? getIP(unsigned long ul_ip)
je me sers d'une fonction de manipulation de bits permettant de decoder l es differents champs de type unsigned char d'une adresse IP contenue dans une variable de type unsigned long:
Note : t'as ton byte réseau qui repose sur 8 bits, un octet, mais il faut savoir qu'en C, un char, signed char ou unsigned char fait CHAR_BIT bits de long (limits.h). Et les autres types intégraux ont des longueurs en bits multiples de celle de *char.
void printIP(unsigned long ul_ip) { unsigned char auch_ip[4];
Les fonctions non-standard (ntoh* et hton*, network to host et vice versa) ainsi que des masques ou macros d'extraction sont tout indiqués pour ce genre de travail.
//affichage de l'IP printf("IP lue = %d.%d.%d.%d", auch_ip[0], auch_ip[1], auch_ip[2], auch_ip[3]); } *********************************************************** Juqu'ici tout va bien. Maintenant j'aimerai ecrire une fonction getIP(), qui non seulement me decode l'IP contenue dans la variable de type unsigned long, mais qui me renvoie l'addresse IP decodee.
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le tableau auch_ip[] ?
Non.
2. Je pense que le plus simple est de faire en sorte que la fonction getI P() renvoie un pointeur sur le premier element du tableau auch_ip[], mais j'ai un petit peu de mal avec la syntaxe...
Pourquoi pas un pointeur en paramètre in-out plutôt qu'en retour, tu te compliques la vie.
*********************************************************** ??? getIP(unsigned long ul_ip)
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le tableau auch_ip[] ?
Non. Tout ce qu'on sait faire, c'est retourner une adresse. Celle-ci doit être valide après l'exécution de la fonction :
- Adresse d'un tableau statique (simple, mais peu conseillé) - Adresse d'un tableau alloué (penser à libérer après usage) - Adresse d'un tableau dont l'adresse a été passé en paramètre.
-- C is a sharp tool
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le tableau
auch_ip[] ?
Non. Tout ce qu'on sait faire, c'est retourner une adresse. Celle-ci
doit être valide après l'exécution de la fonction :
- Adresse d'un tableau statique (simple, mais peu conseillé)
- Adresse d'un tableau alloué (penser à libérer après usage)
- Adresse d'un tableau dont l'adresse a été passé en paramètre.
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le tableau auch_ip[] ?
Non. Tout ce qu'on sait faire, c'est retourner une adresse. Celle-ci doit être valide après l'exécution de la fonction :
- Adresse d'un tableau statique (simple, mais peu conseillé) - Adresse d'un tableau alloué (penser à libérer après usage) - Adresse d'un tableau dont l'adresse a été passé en paramètre.
-- C is a sharp tool
Emmanuel Delahaye
Pourtant en ecrivant une fonction retournant un pointeur de tableau d'elements de type unsigned char, cela semble fonctionner:
*********************************************************** unsigned char (*getIP(unsigned long ul_ip))[] { unsigned char auch_ip[4];
Comportement indéfini. L'adresse n'est plus valide (variable automatique) après avoir quitté la fonction.
-- C is a sharp tool
Harpo
Emmanuel Delahaye wrote:
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le tableau auch_ip[] ?
Non. Tout ce qu'on sait faire, c'est retourner une adresse. Celle-ci doit être valide après l'exécution de la fonction :
Pas nécessairement, il me semble correct qu'une fonction qui généralement retourne une adresse retourne NULL lorsqu'elle n'a pas réussi à allouer le tableau ou le remplir ou que sais-je.
Emmanuel Delahaye wrote:
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le
tableau auch_ip[] ?
Non. Tout ce qu'on sait faire, c'est retourner une adresse. Celle-ci
doit être valide après l'exécution de la fonction :
Pas nécessairement, il me semble correct qu'une fonction qui
généralement retourne une adresse retourne NULL lorsqu'elle n'a pas
réussi à allouer le tableau ou le remplir ou que sais-je.
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le tableau auch_ip[] ?
Non. Tout ce qu'on sait faire, c'est retourner une adresse. Celle-ci doit être valide après l'exécution de la fonction :
Pas nécessairement, il me semble correct qu'une fonction qui généralement retourne une adresse retourne NULL lorsqu'elle n'a pas réussi à allouer le tableau ou le remplir ou que sais-je.
David Noyelle
"Emmanuel Delahaye" wrote in message news:436a57ef$0$19918$
Non. Tout ce qu'on sait faire, c'est retourner une adresse. Celle-ci doit être valide après l'exécution de la fonction :
- Adresse d'un tableau statique (simple, mais peu conseillé) - Adresse d'un tableau alloué (penser à libérer après usage) - Adresse d'un tableau dont l'adresse a été passé en paramètre.
OK merci,
"Emmanuel Delahaye" <emdelYOURBRA@noos.fr> wrote in message
news:436a57ef$0$19918$626a54ce@news.free.fr...
Non. Tout ce qu'on sait faire, c'est retourner une adresse. Celle-ci doit
être valide après l'exécution de la fonction :
- Adresse d'un tableau statique (simple, mais peu conseillé)
- Adresse d'un tableau alloué (penser à libérer après usage)
- Adresse d'un tableau dont l'adresse a été passé en paramètre.
"Emmanuel Delahaye" wrote in message news:436a57ef$0$19918$
Non. Tout ce qu'on sait faire, c'est retourner une adresse. Celle-ci doit être valide après l'exécution de la fonction :
- Adresse d'un tableau statique (simple, mais peu conseillé) - Adresse d'un tableau alloué (penser à libérer après usage) - Adresse d'un tableau dont l'adresse a été passé en paramètre.
OK merci,
Pierre Maurette
Emmanuel Delahaye wrote:
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le tableau auch_ip[] ?
Non. Tout ce qu'on sait faire, c'est retourner une adresse. Celle-ci doit être valide après l'exécution de la fonction :
Pas nécessairement, il me semble correct qu'une fonction qui généralement retourne une adresse retourne NULL lorsqu'elle n'a pas réussi à allouer le tableau ou le remplir ou que sais-je. C'est le problème déjà évoqué de façon sanglante ici-même de confondre
adresse et pointeur. NULL est une valeur valide de pointeur. Le pointeur NULL n'est jamais déréférençable, puisqu'on est *certain* qu'il n'est égal à aucune adresse valide d'objet. Si la fonction renvoie l'adresse d'un objet local et que cette valeur est affectée à un pointeur, au moment de l'affectation, l'objet est mort. Donc ce n'est pas une valeur valide pour le pointeur.
-- Pierre Maurette
Emmanuel Delahaye wrote:
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le
tableau auch_ip[] ?
Non. Tout ce qu'on sait faire, c'est retourner une adresse. Celle-ci
doit être valide après l'exécution de la fonction :
Pas nécessairement, il me semble correct qu'une fonction qui
généralement retourne une adresse retourne NULL lorsqu'elle n'a pas
réussi à allouer le tableau ou le remplir ou que sais-je.
C'est le problème déjà évoqué de façon sanglante ici-même de confondre
adresse et pointeur. NULL est une valeur valide de pointeur. Le
pointeur NULL n'est jamais déréférençable, puisqu'on est *certain*
qu'il n'est égal à aucune adresse valide d'objet.
Si la fonction renvoie l'adresse d'un objet local et que cette valeur
est affectée à un pointeur, au moment de l'affectation, l'objet est
mort. Donc ce n'est pas une valeur valide pour le pointeur.
1. Est-t'il possible d'ecrire une fonction getIP() renvoyant le tableau auch_ip[] ?
Non. Tout ce qu'on sait faire, c'est retourner une adresse. Celle-ci doit être valide après l'exécution de la fonction :
Pas nécessairement, il me semble correct qu'une fonction qui généralement retourne une adresse retourne NULL lorsqu'elle n'a pas réussi à allouer le tableau ou le remplir ou que sais-je. C'est le problème déjà évoqué de façon sanglante ici-même de confondre
adresse et pointeur. NULL est une valeur valide de pointeur. Le pointeur NULL n'est jamais déréférençable, puisqu'on est *certain* qu'il n'est égal à aucune adresse valide d'objet. Si la fonction renvoie l'adresse d'un objet local et que cette valeur est affectée à un pointeur, au moment de l'affectation, l'objet est mort. Donc ce n'est pas une valeur valide pour le pointeur.
