ritorno riferimenti a variabili locali

Question

Eventuali duplicati:
Returning the address of local or temporary variable
Can a local variable’s memory be accessed outside its scope?

Pur sapendo che cosa accade a causa dei seguenti tagli sarebbe utile per capire come sta accadendo . Seguono quattro domande.

Data:

int& foo() 
{ 
    int i = 1; 
    return i; 
} 

E sapendo che in seguito un riferimento al locale chiamato i è de-reference in una temperatura che viene assegnato a intVal e locale i scompare alla fine del foo()

int intVal = foo(); 

Prima questione - nel seguito, il lato destro dell'espressione è lo stesso come sopra così è questo è un caso in cui il compilatore vede il lato sinistro e, in base al contesto, sa di non de-referenziare il riferimento restituito, e invece di creare un nuovo riferimento viene inizializzato con esso?

Seconda domanda - e questo da solo fa sì che il locale i si blocchi mentre intRef è in ambito?

int& intRef = foo(); 

Terza questione - muggito intPtr ottiene l'indirizzo di locale i. Quindi, il compilatore usa il contesto dell'assegnazione e decide di non de-referenziare per ottenere un valore prima di prendere l'indirizzo del riferimento (piuttosto che assumere l'indirizzo di un valore temporaneo contenente il valore de-referenziato)?

quarta questione - fa locale i bastone intorno mentre intPtr è portata?

int* intPtr = &foo(); 

Answer 1

No, nessuno di questi prolungherà la durata della variabile locale. Niente in C++ avrà questo effetto. Gli oggetti locali in C++ vivono fino alla fine dell'ambito in cui sono dichiarati, fine della storia.

L'unica regola che, a prima vista, sembra seguire regole diverse è questo:

int foo() { 
    return 42; 
} 

int main() { 
    const int& i = foo(); 
    // here, `i` is a reference to the temporary that was returned from `foo`, and whose lifetime has been extended 
} 

Cioè, un const riferimento può estendere la durata di un temporanea essere assegnato ad esso.

Ma ciò richiede che la funzione restituisca un valore, non un riferimento, e il chiamato per associare il valore restituito a un riferimento const, nessuno dei quali viene eseguito nel codice.

Answer 2

In nessun caso (non intVal, non intRef e non intPtr) fa sì che i rimanga invariato dopo il ritorno di foo.

Il valore sulla pila precedentemente occupata da i può o non può essere modificato in qualsiasi momento, dopo il ritorno di Foo.

Ad esempio (su alcune CPU e O/S), è probabile che venga modificato da qualsiasi chiamata successiva a una subroutine e potrebbe essere modificato se si verifica un interrupt hardware.