Discussion :

[gangsoleil]

Bonjour,

Je connais bien le C, et tres mal le C++, et j'ai besoin d'explications sur les references, et notamment la difference par rapport a un pointeur.

Ce que j'ai compris : une reference, c'est simplement un pointeur qui ne peut pas etre NULL -- avec une ecriture legerement differente puisque, a mon sens de dev C, la reference est "cachee" lors de l'utilisation.

Est-ce que c'est tout, ou bien j'ai loupe tout un pan de la montagne (*) ?

(*) Montagne, car on m'a recemment explique que les references c'etait vraiment le truc super en C++, que ca sauvait des oursons et tout et tout, et donc si c'est juste ca, bon bah euh, on verra pour les ours plus tart.

[oodini]

Le gros intérêt des références, c'est qu'elles offrent l'efficacité des pointeurs, tout en n'ayant pas à se trimballer une syntaxe pointeur (opérateur de déréférenment, opérateur flèche). Et que la propriété que tu rappelles évite dans la grande majorité des cas de ne pas avoir à s'occuper du danger des pointeurs.

[Davidbrcz]

Tiré de slides que je suis en train d'écrire.

Création d'une référence sur une variable : création d'un alias sur cette dernière.
Une référence n'est pas une autre variable ! C'est la même variable, connue sous un autre nom ! (Preuve, même adresse)
Conséquence : réassigner une référence à une autre variable n'a pas de sens

Pointeur : définition. Variable dont la valeur est l'adresse d'une autre variable
Un pointeur étant une variable à part entière, il peut sans soucis pointer sur une autre variable (sauf si sa valeur a été définie constante).

Ainsi, le passage par référence des arguments te permet de travailler avec tes variables d'origines mais sous un autre nom ! Ce ne sont en aucun cas des copies locales à la fonction. Ca permet de modifier des variables sans avoir à besoin de manipuler des adresses, on continue à manipuler les mêmes variables.

Ca permet d'avoir le polymorphisme d'inclusion (on garde ca pour plus tard :p)

PS/ La référence est peut être implémenté en bas niveau par le compilateur comme un pointeur mais ce n'est pas notre soucis. Au niveau où on manipule les choses, ce sont des notions différentes.

[Arzar]

Il y a aussi une autre raison pour l'existence des références (et c'est en fait la raison historique pour laquelle Stroustrup lors de la conception du C++ a introduit les références en premier lieu), c'est la possibilité avec les références de créer des opérateurs binaires ayant une syntaxe naturelle, du style :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
A operator+(const A& a1, const A& a2)
{
   A a; 
   // faire qqchose qui ait du sens
   //...
   return a;
}
 
 
A b, c;
//...
A a = b + c // appel de l'operator+

Si les références n'existaient pas, alors l'existence des opérateurs seraient compromises car il faudrait faire quelque chose d'assez moche du style :

Code :

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

1
2
3
4
5
6
7
8
9
10
A operator(A* a1,  A* a2)
{
  A a;
  //..
  return a;
} 
 
A b, c;
//...
a = &b + &c; // kezako ? Addition de deux pointeurs ?

[gangsoleil]

Merci pour ces precisions.

la possibilité avec les références de créer des opérateurs binaires ayant une syntaxe naturelle

Dans ce cas precis, il s'agit bien d'une simple facilite d'ecriture (ou de rendre le code plus comprehensible si tu preferes), ce qui aurait tendance a me conforter dans la comprehension que j'avais des references -- modulo la precision apportee par Davidbrcz sur le fait qu'une reference soit partie integrante de la variable, contrairement a un pointeur.

J'ai eu les precisions que je voulais, je resoud donc le thread -- mais si vous avez d'autres precisions a apporter, n'hesitez pas !

[Arzar]

Dans ce cas precis, il s'agit bien d'une simple facilite d'ecriture (ou de rendre le code plus comprehensible si tu preferes)

Pas d'accord, c’est plus que ça à mon avis dans le cas des opérateurs. Avec a = &b - &c; on a une ambiguïté; soit l'on considère que cette syntaxe désigne l'appel de l'opérateur - prenant deux pointeurs en paramètre, soit cette syntaxe désigne la soustraction de deux pointeurs, ce qui a un sens en C/C++. On ne peut pas décider entre les deux...


Edit :
L'explication de Stroustrup en personne sur le pourquoi des références en C++ :

References were introduced primarily to support operator overloading. Doug McIlroy recalls that once I was explaining some problems with a precursor to the current operator overloading scheme to him. He used the word reference with the startling effect that I muttered "Thank you," and left his office to reappear the next day with the current scheme essentially complete. Doug had reminded me of Algol68.

C passes every function argument by value, and where passing an object by value would be inefficient or inappropriate the user can pass a pointer. This strategy doesn't work where operator overloading is used. In that case, notational convenience is essential because users cannot be expected to insert address-of operators if the objects are large. For example:

a = b - c;

is acceptable (that is, conventional) notation, but

a = &b - &c;

is not. Anyway, &b - &c already has a meaning in C, and I didn't want to change that.

It is not possible to change what a reference refers to after initialization. That is, once a C++ reference is initialized, it cannot be re-bound. I had in the past been bitten by Algol68 references where r1 = r2 can either assign through r1 to the object referred to or assign a new reference value to r1 (re-binding r1) depending on the type of r2. I wanted to avoid such problems in C++.

[JolyLoic]

C'est un biais typique d'un développeur C de dire qu'une référence, ce n'est qu'un pointeur, avec juste une syntaxe plus simple .

Mais bon, si on y va par là, on peut dire qu'un pointeur ou un entier, ou même une fonction, c'est tout pareil, ce ne sont que des 0 ou des 1, avec simplement une syntaxe plus simple...

Déjà, en terme de règles du langage, si tu tiens vraiment à comparer référence et pointeur, il vaudrait mieux se dire qu'une référence est un peu comme un pointeur constant, sur lequel on appliquerait l'opérateur de déréférencement partout, sauf au moment où on l'initialise.

En terme d'utilisation, maintenant, ça a des usages un peu différents :
- Ça simplifie le passage d'argument, évitant de devoir expliciter prise d'adresse et déréférencement. Ça a l'air de peu, mais le code est toute de suite bien plus clair. En particulier quand on commence à passer des pointeurs par référence.
- On a la garantie au moment où on l'utilise que ça fait bien référence à quelque-chose, alors qu'un pointeur peut être nul, ou même non initialisé.
- Quand on utilise des références, ça veut dire que l'on n'influe pas sur la durée de vie de l'objet référencé (on pourrait, mais ce ne serait vraiment pas naturel). Quand on passe un pointeur, on ne sait jamais trop ce qu'il va advenir de l'objet pointé.
- Depuis le C++ 11, il existe un nouveau type de référence, nommé les r-value references, qui ont comme propriété que si une fonction f possède une surcharge prenant l'argument par référence, et une autre le prenant par r-value reference, la seconde sera appelée quand on appelle la fonction en lui passant un objet temporaire. Cette propriété est la clef de voute de la notion de move semantic, qui permet d'éviter plein de copies inutiles en C++ en gardant une syntaxe agréable.

[Obsidian]

Hello,

modulo la precision apportee par Davidbrcz sur le fait qu'une reference soit partie integrante de la variable, contrairement a un pointeur.

Tout a été dit, je crois, mais je tiens quand même à réagir sur cette phrase en particulier. Il est également incorrect de dire qu'une référence « est partie intégrante de la variable » car, comme on l'a dit, une référence n'est pas un objet en soi. Une référence est une déclaration faite au compilateur et lui indiquant que le symbole qui suit se rapporte à un objet déjà existant et pas à une nouvelle instance du même type. Voici un code illustrant les explications de Davidbrcz :

Code C++ :

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
17
18
19
20
21
#include <iostream>
 
using namespace std;
 
int main (void)
{
    int    x = 0;
    int &  y = x;
 
    cout << "Adresse de x : " << &x << endl;
    cout << "Adresse de y : " << &y << endl;
 
    x = 5;
    cout << "x vaut désormais 5 ;" << endl;
    cout << "Valeur de x : " << x << " ; valeur de y : " << y << endl;
    y = 6;
    cout << "y vaut désormais 6 ;" << endl;
    cout << "Valeur de x : " << x << " ; valeur de y : " << y << endl;
 
    return 0;
}

Code :

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

1
2
3
4
5
6
Adresse de x : 0x7fff98290e14
Adresse de y : 0x7fff98290e14
x vaut désormais 5 ;
Valeur de x : 5 ; valeur de y : 5
x vaut désormais 6 ;
Valeur de x : 6 ; valeur de y : 6

On voit bien que « x » et « y » ont la même adresse mémoire et que lorsque l'on modifie l'une, on affecte l'autre. C'est parce que « x » et « y » sont deux manières strictement équivalentes de parler de la même chose. Le code généré est identique dans les deux cas et les deux symboles seront totalement résolus à la compilation.

Maintenant, une référence est avant tout sémantique et c'est à la charge du compilateur de faire en sorte que ça fonctionne. Quand on indique que les arguments d'une fonction sont des références, c'est valable sur le principe mais le compilateur ne peut pas savoir à l'avance à quel objet cela va correspondre, contrairement à l'exemple ci-dessus.

D'où le rapport les pointeurs :
— En C, on est obligé d'utiliser les pointeurs pour pouvoir faire des manipulations similaires ;
— En C++, soit la référence est directement résolue à la compilation et on n'en parle plus, soit elle ne pourra l'être qu'à l'exécution et, dans ce cas, le compilo utilise effectivement un pointeur en interne, mais celui-ci est complètement masqué aux yeux du développeur.

Vala, vala, mes 2 ¢, comme on dit.

[gangsoleil]

Il est également incorrect de dire qu'une référence « est partie intégrante de la variable » car, comme on l'a dit, une référence n'est pas un objet en soi.

Yep, j'avais bien compris, mais je ne savais pas comment le dire.

En tout cas, merci encore a tous pour vos explications qui sont limpides, et me permettront surement de continuer a ne pas faire de C++, tout en sachant plus de quoi je parle.