Discussion :

[deubelte]

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 :

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

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 :

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

1
2
 
const int & a=2;

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

Merci

[koala01]

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;

[deubelte]

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 :

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

class A{...};

.

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

Code :

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

1
2
3
4
5
 
int main(){
A a;
const A &b=a;
}

[Invité]

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 :

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
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 :

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

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

[koala01]

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 :

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

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