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]

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

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

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

[diogene]

r0d Pour ergoter un peu :

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.

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 ?

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

???

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,

Ne compile pas

[Médinoc]

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.

Et pourquoi donc ?

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

???

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

Ne compile pas

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

Code :

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

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

[r0d]

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.

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

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

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:

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

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

Ne compile pas

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

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

[diogene]

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)

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

Entièrement d'accord

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.