Lambda Capture and Memory Management

Question

Quando catturo un oggetto per riferimento in un lambda C++ 11, lascia l'oggetto fuori dall'ambito e quindi esegue il lambda, ha ancora accesso all'oggetto. Quando eseguo il seguente codice, la chiamata lambda può ancora accedere all'oggetto, sebbene il distruttore sia già stato chiamato! Qualcuno può spiegare perché questo funziona e perché non ottengo un errore di runtime?

#include <iostream> 

class MyClass { 
public: 
    int health = 5; 
    MyClass() {std::cout << "MyClass created!\n";} 
    ~MyClass() {std::cout << "MyClass destroyed!\n";} 
}; 

int main(int argc, const char * argv[]) 
{ 
    std::function<bool (int)> checkHealth; 
    if(true) { 
     MyClass myVanishingObject; 
     checkHealth = [&myVanishingObject] (int minimumHealth) -> bool { 
      std::cout << myVanishingObject.health << std::endl; 
      return myVanishingObject.health >= minimumHealth; 
     }; 
    } // myVanishingObject goes out of scope 

    // let's do something with the callback to test if myVanishingObject still exists. 
    if(checkHealth(4)) { 
     std::cout << "has enough health\n"; 
    } else { 
     std::cout << "doesn't have enough health\n"; 
    } 
    return 0; 
} 

ecco l'output:

MyClass created! 
MyClass destroyed! 
5 
has enough health 

Answer 1

Secondo the cppreference.com website's documentation of lambda functions

riferimenti ciondolanti

Se un'entità viene catturato da riferimento, implicitamente o esplicitamente, e la funzione viene richiamato l'operatore di chiamata dell'oggetto di chiusura d dopo che la vita dell'entità è terminata, si verifica un comportamento indefinito. Le chiusure C++ non prolungano la durata dei riferimenti acquisiti.

In altre parole, il fatto che sia stato catturato l'oggetto per riferimento e quindi si termini la durata dell'oggetto significa che il richiamo del lambda causa un comportamento non definito. Dal momento che un possibile modo in cui UB potrebbe funzionare è "l'oggetto sembra essere vivo e vegeto anche se l'oggetto è morto", sospetto che stia vedendo un comportamento indefinito che si manifesta come se nulla fosse andato storto.

Sospetto che ciò si verifichi se il compilatore alloca una posizione di stack univoca per la variabile temporanea. Ciò significherebbe che al termine della vita dell'oggetto, prima che ritorni main, la memoria non venga toccata da nulla. Di conseguenza, vedresti la variabile che contiene il valore 5 proprio come prima, poiché nient'altro sta scrivendo sopra di esso.

Spero che questo aiuti!