C++ Indirizzo di oggetti lambda come parametri alle funzioni

Question

la mia esperienza sembra che sia:

• un'espressione lambda creato all'interno di una chiamata di funzione viene distrutta subito dopo l'invocazione
• Chiamata di una funzione che si aspetta un std::function crea un oggetto temporaneo (std :: funzione) dal lambda, e l'oggetto viene distrutto dopo l'invocazione

Questo comportamento può essere osservato con il seguente frammento di codice:

0.123,51641 milioni

const function<void()>* pointer; 

void a(const function<void()> & f) 
{ 
    pointer = &f; 
} 

void b() 
{ 
    (*pointer)(); 
} 

int main() 
{ 
    int value = 1; 
    std::cout << &value << std::endl; 

    // 1: this works  
    function<void()> f = [&]() { std::cout << &value << std::endl; }; 
    a(f); 

    // 2: this doesn't 
    a([&]() { std::cout << &value << std::endl; }); 

    /* modify the stack*/ 
    char data[1024]; 
    for (int i = 0; i < 1024; i++) 
     data[i] = i % 4; 

    b(); 

    return 0; 
} 

Che cosa sta effettivamente accadendo nel secondo caso? C'è un modo corretto per chiamare a() senza creare un oggetto esplicito std::function?

Edit:: Questo entrambe le versioni (1 e 2) compilare solo di destra, ma causa di variazioni uscite:

Versione 1:

0x7fffa70148c8 
0x7fffa70148c8 

Versione 2:

0x7fffa70148c8 
0 

Answer 1

Se si crea un elemento temporaneo, verrà rimosso alla fine della riga. Ciò significa che memorizzare un puntatore su di esso è una cattiva idea, come hai affermato correttamente.

Se si desidera memorizzare un puntatore su un std::function (o qualsiasi altra cosa veramente), è necessario assicurarsi che la durata della vita non termini prima di smettere di usare il puntatore. Ciò significa che hai davvero bisogno di un oggetto con nome di tipo std::function.

Per quanto riguarda ciò che accade nel secondo caso: si crea un lambda temporaneo da passare alla funzione. Poiché la funzione prevede un std::function, verrà creato un valore temporaneo std::function dal lambda. Entrambi saranno distrutti alla fine della linea. Quindi ora hai un puntatore a un temporaneo già distrutto, il che significa che provare a usare l'oggetto puntato ti porterà saldamente in un territorio di comportamento indefinito.

Answer 2

Va bene per lambda stateless. I lambda stateless hanno una conversione implicita al tipo di puntatore a funzione.

Inoltre, vi è sempre una conversione implicita a std :: function <> indipendentemente dal tipo effettivo chiamabile.

Ci sono problemi con il mantenimento di un puntatore ai temporari, anche se. Non l'avevo notato in prima lettura del codice.

Questo non ha nulla a che fare con std :: function, ovviamente.

Answer 3

Gli oggetti temporanei vengono distrutti alla fine dell'istruzione in cui sono stati creati. Lo hai appena dimostrato con un lambda.

La funzione std che si passa la prima volta non è temporanea, quindi dura quanto la variabile. In realtà memorizza una copia del temporaneo.

Per avere i tuoi lamd durano più di una linea, è necessario memorizzarli da qualche parte e avere una durata determinata.

Ci sono molti modi per farlo. La funzione Std è un metodo basato sulla cancellazione del tipo per eseguire la memorizzazione, ovvero memorizzare una funzione std anziché un puntatore a una funzione std. Modificare il tipo di pointer in modo che non sia puntatore (e non costante), eliminare lo & quando lo si assegna e chiamarlo direttamente.

In generale evitare di prendere e memorizzare l'indirizzo dei parametri della funzione di riferimento const come collegamento temporaneo ad essi, a meno che non si rilevi la possibilità di riferimento del rvalore in un altro sovraccarico.