Transmission d'une ref sur const dans une fonction

Version imprimable

Voir 40 message(s) de cette discussion en une page

18/11/2009, 10h46
FabTheGeek

Transmission d'une ref sur const dans une fonction
Bonjour à tous,

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

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
18/11/2009, 11h00
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.
18/11/2009, 14h14
FabTheGeek

Mais on est bien d'accord que

Code:

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...
18/11/2009, 14h36
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é.)
18/11/2009, 19h21
FabTheGeek
donc mettons que
Code:

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?
18/11/2009, 20h08
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).
18/11/2009, 20h31
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+
18/11/2009, 21h40
r0d

Citation:

Envoyé par FabTheGeek

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

Citation:

Envoyé par FabTheGeek

je crois savoir qu'une reference est tjs const.

Non, certainement pas! Tu devrais lire attentivement la FAQ sur les références :)
19/11/2009, 07h25
FabTheGeek
Hola,

ben justement à en croire ton lien:

Citation:

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:

1 2 int a=2; const int& x= a;
soit accepté?
19/11/2009, 09h40
r0d

Citation:

Envoyé par Goten

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:

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.

Citation:

Envoyé par FabTheGeek

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?

Citation:

Envoyé par Marshall cline

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.

Citation:

Envoyé par FabTheGeek

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é.
19/11/2009, 09h52
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.
19/11/2009, 10h22
FabTheGeek

Citation:

Envoyé par r0d

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!
19/11/2009, 10h35
r0d

Je ne comprends pas ce que tu veux dire par

Citation:

Envoyé par FabTheGeek

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

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:

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

Citation:

Envoyé par FabTheGeek

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:

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:

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.

19/11/2009, 11h14
screetch

Citation:

Envoyé par Arzar

Pourquoi est-ce qu'on ne pourrait pas ?

parce que quelqu'un d'autre pourrait la modifier.
19/11/2009, 11h23
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. :fou:

cf mon code un peu plus haut...

Code:

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

19/11/2009, 11h25
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
19/11/2009, 11h26
screetch

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

Voir 40 message(s) de cette discussion en une page