Parametre de fonction

Salut!

Je souhaiterais avoir des précisions quant à l'emploi de ces différentes signatures de fonctions :

1/ void f( MyType mt );
2/ void f( MyType &mt );
3/ void f( MyType *mt );

-> 1/ correspond au passage par valeur donc dans la fonction on fait ce qu'on veut de la valeur. En dehors de f, mt a toujours la meme valeur.

-> 2/ correspond a un passage par référence donc on passe l'adresse d'une variable et si on modifie mt dans la fonction, a la sortie de f la modification est presente

-> et 3/ correspond a la meme chose que 2/ ms pour des pointeurs

Est-ce que tout est exact?


Merci de votre confirmation...

Tyv

Salut,

C'est bien exact...

On peut juste rajouter que la différence entre le 2) et le 3), c'est que dans le cas d'un pointeur, il peut etre NULL, alors qu'une référence ne peut pas l'etre ;)

C'est à vrai dire la seule différence réelle qu'il y aie entre une référence et un pointeur ;)

Bonjour,

Citation:

---

Envoyé par Tyver

-> 1/ correspond au passage par valeur donc dans la fonction on fait ce qu'on veut de la valeur. En dehors de f, mt a toujours la meme valeur.

---

Exact.
Lorsqu'on utilise la passage par valeur, le compilateur effectue une copie du paramètre lorsque la fonction est appelée. Par conséquent, les modification du paramètre effectué à l'intérieur de la fonction vont affecter la copie de la variable passée en paramètre, et non la variable elle-même.

Citation:

---

Envoyé par Tyver

-> 2/ correspond a un passage par référence donc on passe l'adresse d'une variable et si on modifie mt dans la fonction, a la sortie de f la modification est presente

---

Exact. RAS.

Citation:

---

Envoyé par Tyver

-> et 3/ correspond a la meme chose que 2/ ms pour des pointeurs

---

Oui, mais...
Lorsque tu passes un pointeur en paramètre, ce pointeur est copié lors de l'appel à la fonction. Donc si tu modifie le pointeur à l'intérieur de la fonction, il y a de grandes chances pour que cela engendre des problèmes.

Citation:

---

Envoyé par koala01

C'est à vrai dire la seule différence réelle qu'il y aie entre une référence et un pointeur ;)

---

Je ne suis pas d'accord. Une référence, c'est l'adresse de l'endroit où est stocké l'objet. Un pointeur est une variable dans laquelle est stockée l'adresse où est stocké l'objet. Ce n'est pas du tout la même chose.

Je vais de ce pas chercher un peu de litérature sur ce sujet pour étayer mon propos :)

Citation:

---

Je ne suis pas d'accord. Une référence, c'est l'adresse de l'endroit où est stocké l'objet. Un pointeur est une variable dans laquelle est stockée l'adresse où est stocké l'objet. Ce n'est pas du tout la même chose.

---

Ben, c'est quand même la même chose ;)
Une référence ce n'est qu'un pointeur déguisé pour offrir un accès simplifié à la variable. Et le fait que la référence doit obligatoirement pointer vers quelque chose de valide est bien la seule différence avec un pointeur (si on ne pinaille pas).

De toute façon une fois le code compilé, une référence n'est rien d'autre qu'un bête adresse, tout comme un pointeur.

Méééé heu!!! Je vous dis que j'ai raison!! Vous êtes tous nul d'abord!!! :aie:
Désolé, j'ai abusé sur l'apéro :fou:

Plus sérieusement:

Citation:

---

Il est très important de distinguer les pointeurs, qui sont des adresses mémoire, des références qui sont des variables de types très divers.

---

(http://www.ann.jussieu.fr/courscpp/S...Sect03-C1.html)

Citation:

---

Envoyé par faqlite

Utilisez les références quand vous pouvez, et les pointeurs quand vous devez.

---

(http://jlecomte.ifrance.com/c++/c++-...rences-fr.html)

:arrow: Un pointeur dispose de toute une série d'opérateurs, une référence n'en a pas.
:arrow: Contrairement à un pointeur, il est impossible de déclarer une référence sans l'initialiser.
:arrow: Comme l'a dit koala01, un pointeur peut prendre la valeur NULL, la référence non.
:arrow: Les références n'existent qu'en C++. Les pointeurs existent en C et en C++.
:arrow: L'utilisation d'une référence fait gagner un adressage par rapport à un pointeur. Je ne suis pas adepte de l'optimisation, et j'avoue que je ne sais pas si ça a une quelconque importance.

Toutes ces différences, et en particulier les 2 premières, font qu'un pointeur est beaucoup plus dangereux à utiliser qu'une référence.

Le code suivant, par exemple, illustre une erreur assez classique qui ne peut pas arriver si on utilise une référence à la place d'un pointeur:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

void foo(int* p) { p+=5; }   int main(int argc, char* argv[]) { int p = 0;   foo(&p); //on appelle foo en pensant que ça va modifier la valeur de p return 0; }

---

Ensuite, lorsque l'on choisi d'utiliser un pointeur ou une référence, cela implique un choix sémantique. Par exemple, la fonction suivante

Code:

---

1 2 3 4

void foo(const int* p) { *p+=5; }

---

compile, et on ne sait pas à quoi sert ce const. Alors que l'utisation d'une référence constante est trés explicite.

Merci beaucoup pour ces précisions c'est sympa!!
Je crois que ça a fait du bien a tout le monde :p

Bonjour,

Pour rajouter une chose sur les références et les pointeurs.
Lorsque dans mon code je lis :

Code:

---

1 2 3

MonObjet t; foo(t);

---

où foo est une fonction qui prend une référence vers un MonObjet et le modifie.

Si je ne connais pas le prototype de la fonction, rien ne me dis ne me dis dans ce code que t sera modifié (où non). Je peux croire qu'il s'agit d'un passage par valeur.

Alors que si j'avais :

Code:

---

1 2 3

MonObjet t; foo(&t);

---

Où foo est déclaré comme prenant un pointeur vers un MonObjet alors à la lecture de ce code, je vois que t est susceptible d'être modifié.

Par conséquent, je n'utilise les références comme paramètres de fonction lorsque celle-ci ne modifie pas l'objet référencé mais que je gagne à épargner une recopie par valeur (j'utilise alors une référence constante pour garantir cette non modification).
Et j'utilise les pointeurs lorsque la fonction modifie l'objet pointé.
On y gagne en lisibilité, non ?

Citation:

---

Envoyé par Aurelpitiless

Si je ne connais pas le prototype de la fonction, rien ne me dis ne me dis dans ce code que t sera modifié (où non). Je peux croire qu'il s'agit d'un passage par valeur.

---

Je ne vois comment il est possible d'utiliser une fonction sans en connaitre la signature. Je ne vois donc pas l'intérêt de cette remarque.

Citation:

---

Envoyé par Aurelpitiless

[...]alors à la lecture de ce code, je vois que t est susceptible d'être modifié.

Par conséquent, je n'utilise les références comme paramètres de fonction lorsque celle-ci ne modifie pas l'objet référencé mais que je gagne à épargner une recopie par valeur (j'utilise alors une référence constante pour garantir cette non modification).

---

D'où l'intérêt de respecter la const conformité, ainsi la question de se pose plus.

Citation:

---

Envoyé par Aurelpitiless

Et j'utilise les pointeurs lorsque la fonction modifie l'objet pointé.
On y gagne en lisibilité, non ?

---

Je ne sais pas, c'est plus une question d'habitude je pense. Ces petites habitudes qui font que lorsqu'on doit travailler sur le code d'un collègue, on a souvent l'impression que ce code est mauvais ;)

Citation:

---

Je ne vois comment il est possible d'utiliser une fonction sans en connaitre la signature. Je ne vois donc pas l'intérêt de cette remarque.

---

Je pensais surtout en terme de lisibilité dans le cas où tu dois reprendre un source écris par quelqu'un d'autre par exemple.
Dans ce cas je ne tiens pas à lire la doc de chaque fonction utilisée pour savoir si elle modifie ou pas un objet, j'aime bien le voir a la seule lecture du code.

Ca peut permettre de ne pas passer un temps fou à déceler un bug, parce que l'on pense que le paramètre est passé par valeur, et non par référence.

C'est pas faux...

En même temps, si tu passes un paramètre à une fonction sans savoir ce qu'elle va en faire, c'est assez grave... Avec un bon EDI tu fais clic droit + "Go to declaration" et hop tu sais si c'est une référence ou autre chose.

Ceci-dit, le débat (pour ne pas dire troll) pointeur vs référence a déjà eu lieu, je suis sûr que ceux que ça intéresse trouveront plein de pages à lire en fouillant un peu sur ce forum.

Au passage: Si on est malin, on peut faire une référence nulle. Mais c'est du truandage...

Code:

---

1 2	int *p = NULL; int &r = *p;

---

Edit: Et le pire, c'est qu'on peut aussi le faire involontairement...

Citation:

---

Envoyé par Tyver

1/ void f( MyType mt );

-> 1/ correspond au passage par valeur donc dans la fonction on fait ce qu'on veut de la valeur. En dehors de f, mt a toujours la meme valeur.

Tyv

---

Attention, si MyType est une classe, le destructeur sera appelé à la fin de la fonction !

Citation:

---

Envoyé par millie

Attention, si MyType est une classe, le destructeur sera appelé à la fin de la fonction !

---

Merci pour vos réponse et cette dernière aussi que j'ignorais!
Excellent week-end!

Tyv

Tout élément passé par référence/pointeur serait mieux const.

Je ne comprend pas pourquoi tu dis ça. I ly a plein de cas où ce n'est pas vrai. Si l'on souhaite modifier le paramètre dans la fonction par exemple.
Enfin, il doit y avoir un truc qui m'échappe là.

Pourquoi le modifier ?
Si ta fonction doit produire un résultat, il est sémantiquement plus juste qu'elle le retourne sous forme de valeur.

Loufoque, deux mots:

operator <<

(entre autres, évidemment. Et il y a tant de fonctions qui pourraient vouloir retourner deux valeurs à la fois sans avoir de problèmes, comme ceux de java où une allocation dynamique est obligatoire pour ça...).

Citation:

---

Envoyé par loufoque

Pourquoi le modifier ?
Si ta fonction doit produire un résultat, il est sémantiquement plus juste qu'elle le retourne sous forme de valeur.

---

Ca peut également très mal fonctionner dès qu'il y a un peu d'héritage.

Donner en paramètre l'instance permet de faire des manipulations dessus indépendemment de son implémentation (vu que l'on doit pas donner en retour une instance de la classe).

Exemple classique, des opérateurs sur des images :

Code:

---

1 2 3 4 5 6 7

void operateur(Image & out, const Image & in) { if(out.getNumComponents() != in.getNumComponents()) { throw ... } ... }

---

L'image pouvant être spécialisée (ImageRGB, ...)
Et donc le code fonctionnerait comme ça :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

ImageRGB imRGB; ImageRGB imRGBout;   ImageIO::loadJPG("./..", imRGB);   operateur(imRGBout, imRGB);   ...   ImageNB imNB; ImageNB imNBout;   ImageIO::loadJPGRedComponent("...", imNB);   operateur(imNBout, imNB);

---

r0d Pour ergoter un peu :

Citation:

---

Je ne suis pas d'accord. Une référence, c'est l'adresse de l'endroit où est stocké l'objet. Un pointeur est une variable dans laquelle est stockée l'adresse où est stocké l'objet. Ce n'est pas du tout la même chose.

---

Passé en argument d'une fonction, l'argument "pointeur" est l'adresse où est stocké l'objet. C'est devenu une simple valeur, pas une variable. Je préfère pour ma part dire que la référence est l'objet.

Citation:

---

Lorsque tu passes un pointeur en paramètre, ce pointeur est copié lors de l'appel à la fonction. Donc si tu modifie le pointeur à l'intérieur de la fonction, il y a de grandes chances pour que cela engendre des problèmes.

---

Et pourquoi donc ?

Citation:

---

L'utilisation d'une référence fait gagner un adressage par rapport à un pointeur.

---

???

Citation:

---

Par exemple, la fonction suivante

Code:

---

1 2 3 4

void foo(const int* p) { *p+=5; }

---

compile,

---

Ne compile pas

Citation:

---

Envoyé par diogene

Passé en argument d'une fonction, l'argument "pointeur" est l'adresse où est stocké l'objet. C'est devenu une simple valeur, pas une variable. Je préfère pour ma part dire que la référence est l'objet.

---

C'est quand même plus compliqué. Quand on se met à jouer avec les pointeurs (notamment "prendre l'adresse d'une référence"), on prend l'adresse de l'objet en effet. Pour moi, je préfère dire que la référence est un pointeur déguisé, et que chaque utilisation comporte une étoile implicite (cad, int *pi = &ri correspond à int *pi = &*pr_i.

Citation:

---

Envoyé par diogene

Et pourquoi donc ?

---

Sans doute, parce que ceux qui connaissent mal les pointeurs les confondent avec les références...

Citation:

---

Envoyé par diogene

???

---

Dans le source. La référence masque un niveau d'indirection par rapport au pointeur (mais ne fait que le masquer, évidemment).

Citation:

---

Ne compile pas

---

En effet. Par contre, ce code-ci compile, du fait des priorités opératoires:

Code:

---

1 2 3 4

void foo(const int* p) { *p++; }

---

Naturellement, il ne fait pas la même chose (en l'ocurrence, ce code ne fait rien).

Citation:

---

Envoyé par diogene

Pour ergoter un peu :
Passé en argument d'une fonction, l'argument "pointeur" est l'adresse où est stocké l'objet. C'est devenu une simple valeur, pas une variable. Je préfère pour ma part dire que la référence est l'objet.

---

Peut-être n'ais-je pas bien compris ce que tu voulais dire, mais je soutiens qu'un pointeur, qu'il soit passé en argument de fonction ou non, est une variable. Si tel n'était pas le cas, aucune arythmétique ne serait applicable aux pointeurs.

Citation:

---

Envoyé par Christian Casteyde

Les pointeurs sont justement des variables qui contiennent l'adresse d'autres objets[...]

---

(http://c.developpez.com/tutcpp/x1541.php)

Citation:

---

Envoyé par diogene

Et pourquoi donc ?

---

Parce que, justement, un pointeur est une variable, ce qui induit donc une indirection supplémentaire. En revanche, et je m'en doutais un peu, ce point semble être négligeable:

Citation:

---

Envoyé par faqlite

En lui-même le niveau d'indirection supplémentaire est de la gnognotte

---

(http://jlecomte.ifrance.com/c++/c++-...antics-fr.html )

Citation:

---

Envoyé par diogene

Ne compile pas

---

Hum oui, désolé, je me suis trompé :oops: Erreur de copier/coller :lol:
Je voulais dire:

Citation:

---

void foo( const int* p)
{
p+=5; // pas de déréférencement
}

---

Citation:

---

Peut-être n'ais-je pas bien compris ce que tu voulais dire, mais je soutiens qu'un pointeur, qu'il soit passé en argument de fonction ou non, est une variable.

---

Ce que je veux dire c'est que les arguments d'une fonction (hormis les références) sont dans un contexte de valeur.
Dans le cas d'un pointeur qui nous occupe, je peux mettre
- une adresse (NULL, &objet,...)
- ou un pointeur et dans ce cas, celui-ci est interprété comme la valeur du pointeur, autrement dit l'adresse de l'objet pointé (ou NULL)
- ou une expression (genre p+1) qui évaluée fournit elle aussi une valeur de type adresse de... (Dans p+1, p est aussi dans un contexte de valeur)

Citation:

---

Christian Casteyde a écrit :
Les pointeurs sont justement des variables qui contiennent l'adresse d'autres objets[...]

---

Entièrement d'accord

Citation:

---

Parce que, justement, un pointeur est une variable, ce qui induit donc une indirection supplémentaire.

---

Entièrement pas d'accord pour une référence en argument de fonction. C'est vrai si on reste dans le code où la référence est définie puisqu'alors le compilateur sait quel objet correspond à la référence (mais ce n'est pas très utile). Mais en passage d'argument, le seul moyen d'identifier l'objet dans la fonction est de connaître son adresse et c'est ce qui est passé à la fonction.

diogene a raison, il n'y a aucune différence d'indirection entre:

Code:

---

1 2 3 4 5 6 7 8 9 10

void UneFonction(UneClasse &obj) { obj.uneFonctionNonVirtuelle(); }   void UneAutreFonction() { UneClasse unObjet; UneFonction(unObjet); }

---

et:

Code:

---

1 2 3 4 5 6 7 8 9 10

void UneFonction(UneClasse *pObj) { pObj->uneFonctionNonVirtuelle(); }   void UneAutreFonction() { UneClasse unObjet; UneFonction(&unObjet); }

---

Médinoc

Citation:

---

C'est quand même plus compliqué. Quand on se met à jouer avec les pointeurs (notamment "prendre l'adresse d'une référence"), on prend l'adresse de l'objet en effet. Pour moi, je préfère dire que la référence est un pointeur déguisé, et que chaque utilisation comporte une étoile implicite (cad, int *pi = &ri correspond à int *pi = &*pr_i.

---

C'est une autre manière de dire la même chose : Si la référence est un pointeur (déguisé) déréférencé par une étoile (implicite) c'est qu'elle désigne l'objet dont l'adresse correspond au pointeur (déguisé).
Accessoirement, j'ai toujours trouvé incohérente la définition des références par
int &p
au lieu de
int *& p qui seraitcohérent avec int * pi = &p
On retrouve encore ton étoile implicite