Discussion :

[ram-0000]

Bonjour,

En lisant un code hier, je suis tombé sur cette écriture :

Code :

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

1/ ==> int fct( int const & reference)

Il semble que cela soit identique à :

Code :

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

2/ ==> int fct( const int & reference)

Dans ma tête,

• l'écriture 1 signifiait que reference est un alias non modifiable vers une variable de type int modifiable
• l'écriture 2 signifiait que reference est un alias modifiable vers une variable de type int non modifiable

c'est à dire que :

• dans le cas 1, on pouvait faire reference = <autre valeur> ce qui modifie la valeur de l'objet aliasé
• dans le cas 2 on pouvait faire reference = <autre alias> ce qui modifie la variable vers laquelle est aliasée la référence.

En fait il semble que les 2 écritures soient les mêmes et signifient que reference est un alias non modifiable vers une variable de type int non modifiable.

Est ce que quelqu'un peut me confirmer cette compréhension ?

Une autre question à ce moment, comment peut on modifier l'aliasing d'une référence vers une autre variable (du même type bien sûr). Je ne sais même pas si cette question à un sens ni même si cela peut être utile de la faire.

[Médinoc]

Étant donné que les références ne sont jamais modifiables, la démonstration est plus simple avec les pointeurs:

• int const * et const int * sont équivalents (la première écriture est plus "la règle", la second est plutôt l'exception).
• int * const indique un pointeur non-modifiable vers un entier modifiable.

Une autre question à ce moment, comment peut on modifier l'aliasing d'une référence vers une autre variable (du même type bien sûr). Je ne sais même pas si cette question à un sens ni même si cela peut être utile de la faire.

C'est supposé être impossible, c'est à ça que servent les références.
Mais on peut toujours tricher, en faisant un type contenant une référence et en utilisant le terrible memcpy() (ou std::copy() avec des reinterpret_casts en unsigned char*)...

[ram-0000]

Étant donné que les références ne sont jamais modifiable...

Je ne savais pas (et en fait, je ne m'étais pas posé la question avant aujourd'hui. Donc j'ai la réponse à mes questions existencielles !!

Mais on peut toujours tricher, en faisant un type contenant une référence et en utilisant le terrible memcpy() (ou std::copy() avec des reinterpret_casts en unsigned char*)...

Avec ceci, on entre dans la 4eme dimension du code sale (et surtout incompréhensible).

[Médinoc]

J'avais fait une classe pour ça: http://www.developpez.net/forums/d62...ference-const/

[poukill]

En fait const s'applique sur le mot qui le précède. Dans le cas où il n'y a rien avant, on prend celui d'après. C'est l'exception dont parlait Médinoc.
Donc un pointeur dont tu ne peux modifier ni le pointeur lui même ni l'objet pointé s'écrit:

Code :

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

int f ( int const * const)

[3DArchi]

Étant donné que les références ne sont jamais modifiables....

Avec ceci, on entre dans la 4eme dimension du code sale (et surtout incompréhensible).

En fait, avec boost.optional, on peut faire des références réassignables :

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
 
int main()
{
   int val_1 (5);
   int val_2 (42);
 
   boost::optional<int&> opt_ri;
   opt_ri = val_1;// opt_ri est liée à val_1
   *opt_ri = 12;// on change la valeur de val_1
   *opt_ri = val_2; // on change la valeur de val_1 qui vaut maintenant celle de val_2
   opt_ri = val_2;// on réassigne opt_ri : opt_ri est liée à val_2
   *opt_ri = 5; // on change la valeur de val_2
 
   return 0;
}