Parametro passato con riferimento const restituito da riferimento const

Question

Stavo leggendo C++ Faq Second Edition, numero faq 32.08.

FAQ dice che il parametro passato da riferimento const e restituito da riferimento const può causare riferimento ciondolante.

Ma va bene se il parametro viene passato per riferimento e restituito per riferimento.

Ho capito che non è sicuro in caso di riferimento const ma come è sicuro nel caso in cui il parametro non è riferimento const.

ultima linea di FAQ dice "Si noti che se una funzione accetta un parametro di riferimento non-const (ad esempio, f (string & s)), restituendo una copia di questo parametro di riferimento è sicuro perché un temporaneo non può essere passato da riferimento non const. "

Hai bisogno di qualche intuizione su questo !!

Answer 1

se avete come

const Foo & bar(const Foo &f) { return f; } 

e chiamarlo come

const Foo &ret = bar(Foo()); 

Questo compila, ma il problema è che la società 'ret' è un riferimento ciondolante, perché l'oggetto temporaneo creato dalla chiamata a Foo() viene liberato dopo la restituzione della barra. La sequenza di esecuzione dettagliata ecco:

1. temporanea Foo è allocato
2. bar è chiamato con un riferimento all'oggetto temporaneo
3. bar restituisce il riferimento
4. ora che bar è tornata Foo temporanea viene rilasciato
5. il riferimento è ora penzolava come l'oggetto è stato distrutto

Tuttavia, se si ha dichiarato come Foo

Foo & bar(Foo &f) { return f; } 

allora la vostra barra di chiamata (Foo()) non sarebbe accettato da compilatore. Quando si passa un oggetto temporaneo a una funzione, è possibile prenderlo solo per riferimento const o come copia; questo fa parte della definizione del linguaggio.

Answer 2

I temporanei possono essere passati per riferimento const - quando la funzione restituisce i provvisori vengono smontati, quindi il chiamante viene lasciato con un riferimento ciondolante.

Ad esempio:

#include <iostream> 

using namespace std; 

int const& output(int const& x) 
{ 
    cout << x << endl; 

    return x; 
} 

int main() 
{ 
    int a = 1; 

    int const& ref1 = output(a); // OK 

    int const& ref2 = output(a+1); // bad 

    return 0; 
} 

Answer 3

penso che questo esempio sarà utile:

const int& f(const int& n) 
{ 
    return n; 
} 

int f1(int& n) 
{ 
    return n; 
} 


int main(int argc, char **argv) 
{ 
    //Passing a reference to an anonymous object created by 
    //the compiler to function f() 
    const int& n = f(10); 

    //Undefined behavior here as the scope of the anonymous object 
    //was only till previous statement 
    int k = n + 10; 

    //Compiler error - Can not pass non-const reference to a anonymous object 
    int n = f1(10); 
} 

Answer 4

Here è una pagina di C++ 0x rvalue riferimenti che inizia con un riassunto abbastanza decente di come lvalue e rvalues ​​lavorano in C++, insieme con il modo in cui sono autorizzati a legare con riferimenti.

La maggior parte degli articoli che troverete sui riferimenti di rvalue in C++ 0x vi daranno un'idea di questo.