intérêt de const int &

Bonjour
Je me suis posé la question sur l'intérêt de l'instruction const int &.
Je comprends parfaitement que ce soit utile pour renvoyer une valeur par une fonction dont on souhaite qu'elle soit pas modifiable.
Par exemple, la fonction operator[]. Ce qui nous permet de faire du read-only.

Mais à l'intérieur d'un programme, à quoi cela pourrait bien servir?

L'intérêt d'une référence, c'est que c'est une lvalue modifiable. Si on lui attribue const, elle ne sera plus modifiable.

Par exemple,

Code:

---

1 2 3

int o=3; const int& e=o;

---

Quel serait l'intérêt d'avoir une référence constante sur o?


autre cas où l'on peut avoir une référence constante:

Code:

---

1 2	const int & a=2;

---

Mais quel serait l'intérêt d'avoir une référence sur 2?

Merci

Salut,

De manière générale, il n'y a aucun intérêt à déclarer une référence sur un type primitif, surtout si c'est une référence constante, la copie bit à bit d'un primitif étant parfaitement sécurisante et rapide d'une part, et les références étant représentées dans le code binaire sous la forme de ... pointeurs vers l'objet référencé.

Faire en sorte de prendre l'adresse de la variable référencée et de la copier à chaque fois présente donc souvent l'inconvénient de nécessiter... l'utilisation d'une variable de taille fixe (celle d'un pointeur), y compris lorsqu'il s'agit de renvoyer une variable utilisant un nombre inférieur de bits.

C'est la raison pour laquelle de nombreux modèles de fonctions / classes sont surchargés ou spécialisés de manière à prendre les types primitifs par valeur ;)

Il y a, cependant, le cas particulier de l'opérateur non constant []: C'est, à peu près, le seul cas où il est effectivement intéressant de renvoyer une référence non constante sur un type primitif afin de permettre l'affectation d'une nouvelle valeur à l'élément obtenu avec un code proche de obj[5]=45; ;)

OK, merci pour la réponse. Ce que tu dis confirme ce que je disais. Il n'y a pas grand intérêt à prendre la référence constante d'un type primitif.

Mais je ne parlais pas seulement d'un type primitif. Considérons le cas général d'un objet a de type A.

Code:

---

class A{...};

---

.

Quel serait l'intérêt de faire cela:

Code:

---

1 2 3 4 5

int main(){ A a; const A &b=a; }

---

Bonjour,
Avoir une référence(ou un pointeur),qu'elle soit constante ou pas, sur un objet définie dans le même bloc presente peu d'interêt(on peut directement utiliser l'objet). Par contre,ça peut être utile dès que l'on veut récupérer un objet qu'on ne modifiera pas. Par exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

class A { /*...*/ void fonctionConst1() const; void fonctionConst2() const; /*...*/ };   //utilisation 1   void prendRefConst(A const& a) { a.fonctionConst1(); a.fonctionConst2(); }   //utilisation 2   class B { A const& renvoiRefConst(); };     void f() { B objB; A const& objA = objB.renvoiRefConst(); objA.fonctionConst1(); objA.fonctionConst2(); /*   plutot que   objB.renvoiRefConst().fonctionConst1();   objB.renvoiRefConst().fonctionConst2(); */ }

---

Dans les deux cas, on pourrait utiliser une copie de l'objet, mais :
-l'objet peut être gros ce qui rend la copie plus longue et la mémoire utilisée plus importante
-l'objet peut être non-copiable
-l'objet peut référé à un objet dans type derivé qui serait coupé lors de la copie

Dans le premier cas, on pourrait utiliser une reférence non constante mais lors de l'appel, pas mal de code serait interdit :

Code:

---

1 2 3 4 5 6 7 8 9

prendRefNonConst(A()); // interdit const A a; prendRefNonConst(a); // interdit // disons que A à un constructeur non explicit prenant un C class C{/*...*/}; prendRefNonConst(C()); //interdit C c; prendRefNonConst(c); //interdit

---

L'avantage des références, c'est qu'elles permettent de profiter du comportement polymorphe de l'objet référencé.

Elle peut donc être utilisée dans certains patterns (comme le pattern "décorateur") en lieu et place d'un pointeur.

De plus, il faut savoir que la référence (même constante) est en étroite relation avec l'objet référencé: si tu modifie l'objet, tu observe la même modification dans la référence, comme démontre l'exemple suivant:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

struct A { A():i(5){} void print() const{std::cout<< i<<std::endl;} int i; }; int main() { A obj; A const & ref = obj; ref.print(); // affiche "5" obj.i = 10; ref.print(); // affiche "10" return 0; }

---