Discussion :

[Tyver]

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

[koala01]

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

[r0d]

Bonjour,

-> 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.

-> 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.

-> 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.

[r0d]

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

[Laurent Gomila]

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.

[r0d]

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

Plus sérieusement:

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)

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

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

Un pointeur dispose de toute une série d'opérateurs, une référence n'en a pas.
Contrairement à un pointeur, il est impossible de déclarer une référence sans l'initialiser.
Comme l'a dit koala01, un pointeur peut prendre la valeur NULL, la référence non.
Les références n'existent qu'en C++. Les pointeurs existent en C et en C++.
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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Tyver]

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

[aurelman]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[r0d]

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.

[...]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.

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

[aurelman]

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.

[r0d]

C'est pas faux...

[Laurent Gomila]

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.

[Médinoc]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[millie]

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 !

[Tyver]

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

[loufoque]

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

[r0d]

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à.

[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.

[Médinoc]

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...).

[millie]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);