Discussion :

[FabTheGeek]

Bonjour à tous,

une petite question concernant la transmission d'arguments par référence dans les fonctions.

Code :

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

1
2
int f(const int& r)
{ }

nécessite-il forcément que la variable transmise soit un int constant? Ou est ce juste une sémantique spéciale pour dire que la variable, bien que passée par ref ne sera pas modifiée?

Merci

[r0d]

bonjour,

le const n'est pas obligé, il s'agit juste d'un attribut sémantique qui dit à celui qui va utiliser: "tu peux être sûr que cette variable ne sera pas modifiée".


Sinon quelques remarques:

Dans le cas d'un type natif, le passage par référence constante ne change absolument rien au passage par valeur.

On peut lire parfois que le passage par référence constante aide le compilateur à optimiser dans le cas d'un type complexe. C'est faux. Le compilateur ne peut pas optimiser à cause de l'existence du mot clé mutable.

[FabTheGeek]

Mais on est bien d'accord que

Code :

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

const int& a

signifie : déclarer pour argument une référence vers un int constant ? Et non une référence constante (redondance )vers un int? N'est ce pas?

A moins que le mécanisme de déclaration de variable et celui d'argument ne fonctionnent pas de la même façon...

[Goten]

Oui c'est une référence sur constante. (et par abus de langage on parle de référence constante).
le const s'applique toujours à ce qui le précéde sauf si il y'a rien avant il s'applique à ce qui est juste après.
ie :
const T& == T const &


(beaucoup préfèrent la seconde écriture afin d'éviter ce genre d'ambiguïté.)

[FabTheGeek]

donc mettons que

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int a=2;
int b;
 
int main()
{
 
b=g(a);
return 1;
}
 
int g(const int& x)
{ }

dans le premier appel je dis bien x pointe vers a qui n'est pourtant pas constant... et je devrais donc avoir une erreur non?

[Arzar]

Non, ce que ça veut dire c'est que dans la fonction tu ne pourras pas modifier x (et donc pas a, vu que x n'est qu'un alias pour a).

[FabTheGeek]

Hola,

mais const int& x veut bien dire que ce que pointe x est une constante non? et non pas que x est une reference constante (ce qui est redondant puisque je crois savoir qu'une reference est tjs const).

a+

[r0d]

mais const int& x veut bien dire que ce que pointe x est une constante non?

Pour être précis, const int & x, en paramètre d'un fonction f(), signifie juste que dans la portée de la fonction f(), x ne peut pas être modifié. En fait, il y a un const_cast caché (mais qui ne coûte rien puisque ça ne concerne que la compilation).

je crois savoir qu'une reference est tjs const.

Non, certainement pas! Tu devrais lire attentivement la FAQ sur les références

[FabTheGeek]

Hola,

ben justement à en croire ton lien:

Comment faire pour modifier une référence de façon qu'elle désigne un autre objet ?
[haut]
auteur : Marshall Cline
Ce n'est pas possible.

On ne peut pas séparer le référé de sa référence.

Contrairement aux pointeurs, lorsqu'une référence est liée à un objet, elle ne peut pas être réaffectée à un autre objet. La référence en elle-même n'est pas un objet (elle n'a pas d'identité : prendre l'adresse d'une référence retourne l'adresse du référent).

De ce point de vue, une référence est similaire à un pointeur constant

int* const p

par opposition à un pointeur sur une constante

const int* p

En dépit d'une certaine ressemblance, ne confondez pas les références et les pointeurs ; ce n'est pas du tout la même chose.

une référence pourrait bien être assimilé à un pointeur constant. C'est ce que je voulais dire, maintenant effectivement l'objet pointé ne l'est pas forcément.

Seulement ce qui me gêne c'est le "const" de la variable pointée...
On est bien d'accord que const int& x signifie: x est une reference à un int constant ?
Si cela est vrai comment il est possible que:

Code :

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

1
2
int a=2;
const int& x= a;

soit accepté?

[r0d]

Oui c'est une référence sur constante. (et par abus de langage on parle de référence constante).

Je ne suis pas trop d'accord avec ça. Dans:

Code :

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

void f(const int & a)

c'est la référence sur a qui est constante. La variable pointée par a, on ne sait pas si elle est contante.

ben justement à en croire ton lien:

une référence pourrait bien être assimilé à un pointeur constant. C'est ce que je voulais dire, maintenant effectivement l'objet pointé ne l'est pas forcément.

Que dit la FAQ?

De ce point de vue, une référence est similaire à un pointeur constant

De ce point de vue, c'est à dire que dans le sens où l'on ne peut pas modifier l'objet pointé par la référence. De ce point de vue oui, c'est comparable, mais sinon c'est très différent.

Il faut bien comprendre qu'un pointeur c'est un objet, et une référence c'est l'adresse d'un objet. Une référence n'est pas un objet, mais la syntaxe est la même, ce qui porte à confusion (chose qui est fréquemment critiquée d'ailleurs, notamment par les programmeurs qui viennent du C).

Un pointeur est un objet qui contient l'adresse de l'objet pointé. Cette encapsulation permet de définir des fonctionalités aux pointeurs (comme pour n'importe quel objet). C'est ce qui permet ce que l'on appelle l'arithmétique de pointeur. Si on a un pointeur p, on peut faire p+1, p-1, p++, etc. Ces opérateurs ('-', '+', ´--', '++', etc.) sont définis de la même façon que l'on définit des opérateurs dans nos propres classes. Ceci est impossible à faire pour une référence car une référence n'est pas un objet.

On est bien d'accord que const int& x signifie: x est une reference à un int constant ?

Comme je l'ai dit plus haut, je ne suis pas d'accord avec ça. Moi je dirais: x est une référence constante sur un objet de type entier. C'est la référence qui est constante, par l'objet pointé.

[screetch]

x est une référence (constante dans le sens ou on ne peut pas "rebinder" une référence) read-only (c'est a dire, const en termes C++) sur une variable.
La variable peut changer en dehors de la fonction; dans ce cas la nouvelle valeur sera mise a jour lorsqu'on utilise la référence.

cela signifie simplement que cet acces a la variable sera read-only quoi.

[FabTheGeek]

Comme je l'ai dit plus haut, je ne suis pas d'accord avec ça. Moi je dirais: x est une référence constante sur un objet de type entier. C'est la référence qui est constante, par l'objet pointé.

Mais une référence est constante par définition, on ne peut pas modifier l'objet pointé, par contre je suis d'accord que la valeur, elle est modifiable. Et c'est la que je ne comprend pas le const int& x en argument puisqu'on ne peut pas imposer à la variable référencé d'être constante!

[r0d]

Je ne comprends pas ce que tu veux dire par

on ne peut pas modifier l'objet pointé, par contre [...] la valeur, elle est modifiable.

[screetch]

on ne peut pas changer d'avis sur l'objet sur lequel on veut pointer
la valeur de l'objet peut être changée par un autre moyen par contre

Code :

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

1
2
3
4
5
6
7
8
9
void doWeirdStuff(const int& original, int& out)
{
  printf("%d\n", original);
  out = 2;
  // original etait marqué const mais maintenant il a changé...
  printf("%d\n", original);
}
int a = 0;
doWeirdStuff(a, a);

[Arzar]

Et c'est la que je ne comprend pas le const int& x en argument puisqu'on ne peut pas imposer à la variable référencé d'être constante!

Pourquoi est-ce qu'on ne pourrait pas ?

Je récapitule les règles de bind entre référence et référé :

Code :

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

1
2
3
4
5
 
               ref                const ref
lvalue         #1  Oui          #2  Oui
const lvalue   #3  Non          #4  Oui
rvalue         #5  Non          #6  Oui

Ce qui donne en code :

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
17
18
19
20
21
 
void ref(int&){}
void cref(const int&){}
 
int main()
{
void ref(int&){}
void cref(const int&){}
 
int main()
{
   int i = 1;  //lvalue
   const int j = 2;  // const lvalue
 
   ref(i); // #1
   cref(j); // #2
   // ref(j); // #3 //error C2664: 'ref' : cannot convert parameter 1 from 'const int' to 'int &'
   cref(j); //#4
  // ref(5); // #5 rvalue // error C2664: 'ref' : cannot convert parameter 1 from 'int' to 'int &'
  cref(6); //#6 rvalue
}

Les régles de bind ont été conçu pour authoriser une flexibilité maximale tout en évitant les catastrophes. Dans le cas qui te préoccupe (#2), on est tout à fait autorisé à rajouter une contrainte : dans la fonction la référence sera constante, donc on ne pourra pas modifier l'objet référé, même s'il n'est pas const à la base.

Par contre, dans un cas comme #3 c'est interdit. Ça serait trop dangereux d'autoriser à modifier la référence dans la fonction alors que l'objet référé est const ! Pareil pour le cas #5 : ça n'a pas beaucoup de sens de vouloir modifier une rvalue. Dans le code que j'ai donné plus haut, la rvalue est le nombre "5". C'est une variable temporaire, qui n'a pas de nom et pas d'adresse, donc on ne peut pas la modifier, ce qui est bien reflété dans les règles de bind.

Edit : sinon, je suis d'accord avec rOd, ça ne me dérange pas de parler de référence constante, même si c'est peut être un très léger abus de langage. En fait la différence fondamentale entre un pointeur et une référence c'est qu'une référence n'est pas rebindable.

[screetch]

Pourquoi est-ce qu'on ne pourrait pas ?

parce que quelqu'un d'autre pourrait la modifier.

[Arzar]

Personne ne peut modifier une référence constante vu qu'elle est ... constante !
J'ai l'impression qu'on ne parle pas de la même chose.

[screetch]

cf mon code un peu plus haut...

Code :

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

1
2
3
4
5
6
7
8
9
void doWeirdStuff(const int& original, int& out)
{
  printf("%d\n", original);
  out = 2;
  // original etait marqué const mais maintenant il a changé...
  printf("%d\n", original);
}
int a = 0;
doWeirdStuff(a, a);

[Goten]

Comme je l'ai dit au début amha c'est un problème de terminologie... vous utilisez (on) pas les mêmes termes pour désigner la même chose

[screetch]

c'est pour ca que pour la compréhension du texte il serait bon de remplacer const par "read-only".