Const reference e lvalue

Question

Non possiamo scrivere int& ref = 40 perché abbiamo bisogno di lvalue sul lato destro. Ma possiamo scrivere const int& ref = 40. Perché è possibile? 40 è rvalue invece lvalue

So che questa è un'eccezione, ma perché?

Answer 1

Come Stroustrup dice:

L'inizializzatore di un const T & Non occorre essere un lvalue o anche di tipo T. In tal caso:

[1] Primo, conversione di tipo implicita T viene applicato se necessario.

[2] Quindi, il valore risultante viene posto in una variabile temporanea di tipo T.

[3] Infine, questa variabile temporanea viene utilizzato come valore del inizializzatore.

Quindi, quando si digita const int& ref = 40, la variabile temporanea int viene creata dietro le quinte e il riferimento è associato a questa variabile temporanea.

Answer 2

C'è una regola nella lingua che consente di associare un riferimento di constval a un valore. La ragione principale di questa regola è che, se non era presente, allora si dovrebbe fornire diversi sovraccarichi di funzioni per essere in grado di utilizzare provvisori come argomenti:

class T; // defined somewhere 
T f(); 
void g(T const &x); 

Con questa regola nel luogo che si può fare g(f()) , senza di essa, per essere in grado di farlo si dovrà creare una diversa g overload che accetta un rvalue (e questo è da un tempo in cui rvalue riferimenti non erano nemmeno nella lingua!)

Answer 3

perché è possibile?

40 è un letterale qui. I riferimenti costanti possono essere inizializzati con letterali e temporanei per prolungare la loro vita. Questo può essere fatto in questo modo da un compilatore:

int const& ans = 40; 
// transformed: 
int __internal_unique_name = 40; 
int const& ans = __internal_unique_name; 

Un'altra situazione è quando si dispone di una funzione, ad esempio:

void f(std::string const& s); 

e si desidera chiamare con

f("something"); 

Questo la variabile temporanea può essere solo associata al riferimento const.

Answer 4

È possibile associare un valore rval a un riferimento const. Il linguaggio garantisce che l'oggetto associato sopravvive fino a quando non termina lo scopo del riferimento e anche in modo statico chiama il distruttore corretto. Questo è ad es. utilizzato in un'implementazione ScopeGuard (http://www.drdobbs.com/cpp/generic-change-the-way-you-write-excepti/184403758?pgno=2) per avere un comportamento simile a un distruttore virtuale senza pagare una chiamata al metodo virtuale.