gestione della memoria per lambda in C++ 11

Question

Qualcuno potrebbe descrivere il motivo per cui questo codice non funziona (su GCC4.7.3 errori di segmento prima di tornare dalla chiamata)?

#include <iostream> 
#include <functional> 
#include <memory> 

using namespace std; 

template<typename F> 
auto memo(const F &x) -> std::function<decltype(x())()> { 
    typedef decltype(x()) return_type; 
    typedef std::function<return_type()> thunk_type; 
    std::shared_ptr<thunk_type> thunk_ptr = std::make_shared<thunk_type>(); 

    *thunk_ptr = [thunk_ptr, &x]() { 
     cerr << "First " << thunk_ptr.get() << endl; 
     auto val = x(); 
     *thunk_ptr = [val]() { return val; }; 
     return (*thunk_ptr)(); 
    }; 

    return [thunk_ptr]() { return (*thunk_ptr)(); }; 
}; 

int foo() { 
    cerr << "Hi" << endl; 
    return 42; 
} 

int main() { 
    auto x = memo(foo); 
    cout << x() << endl ; 
    cout << x() << endl ; 
    cout << x() << endl ; 
}; 

mie ipotesi originali:

1. ogni std::function<T()> è un pò riferimento/shared_ptr a qualche oggetto che rappresenta la chiusura. Cioè il tempo di vita del valore prelevato è limitato da esso.
2. std::function<T()> l'oggetto ha un operatore di assegnazione che abbandonerà la chiusura precedente (termina i valori di durata di vita selezionati) e assumerà la proprietà di un nuovo valore.

P.S. Questa domanda ha sollevato dopo aver letto question about lazy in C++11

Answer 1

Questo è il codice problematico:

[thunk_ptr, &x]() { 
    auto val = x(); 
    *thunk_ptr = [val]() { return val; }; 
    return (*thunk_ptr)(); // <--- references a non-existant local variable 
} 

Il problema è che il locale thunk_ptr è una copia dal contesto. Cioè, nel compito *thunk_ptr = ... il thunk_ptr si riferisce alla copia di proprietà dell'oggetto funzione. Tuttavia, con l'assegnazione l'oggetto funzione cessa di esistere. Cioè, nella riga successiva thunk_ptr si riferisce a un oggetto appena distrutto.

ci sono alcuni approcci per risolvere il problema:

1. Invece di fantasia, basta tornare val. Il problema qui è che return_type potrebbe essere un tipo di riferimento che potrebbe causare il fallimento di questo approccio.

2. ritorno il risultato direttamente dalla incarico: prima l'assegnazione thunk_ptr è ancora vivo e dopo la cessione è restituire ancora un riferimento all'oggetto std::function<...>():

   return (*thunk_ptr = [val](){ return val; })(); 
   

3. sicuro una copia di thunk_ptr e utilizzare questo copia per chiamare l'oggetto funzione nella dichiarazione return:

   std::shared_ptr<thunk_type> tmp = thunk_ptr; 
   *tmp = [val]() { return val; }; 
   return (*tmp)(); 
   

4. Salvare una copia di riferimento a std::function e usarlo inst ead di riferirsi a campo che appartiene a sovrascritto chiusura:

   auto &thunk = *thunk_ptr; 
   thunk = [val]() { return val; }; 
   return thunk();