C++ Adresse von Lambda-Objekten als Parameter an Funktionen

Question

Aus meiner Erfahrung scheint es, dass entweder:

• Ein Lambda-Ausdruck in einem Funktionsaufruf erstellt unmittelbar nach dem Aufruf zerstört
• Aufruf eine Funktion, die ein std::function erwartet erzeugt ein temporäres Objekt (std :: function) aus dem Lambda, und dieses Objekt wird nach dem Aufruf zerstört

Dieses Verhalten kann mit dem folgenden Code-Schnipsel zu beachten:

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; 
} 

Was genau passiert eigentlich im zweiten Fall? Gibt es eine korrekte Möglichkeit, a() aufzurufen, ohne ein explizites Objekt std::function zu erstellen?

Edit:: Diese beiden Versionen (1 und 2) kompiliert nur Recht, sondern führt in verschiedenen Ausgängen:

Version 1:

0x7fffa70148c8 
0x7fffa70148c8 

Version 2:

0x7fffa70148c8 
0 

Answer 1

Wenn Sie ein temporäres erstellen, ist es am Ende der Zeile gegangen. Dies bedeutet, dass das Speichern eines Zeigers eine schlechte Idee ist, wie Sie richtig festgestellt haben.

Wenn Sie einen Zeiger auf eine std::function (oder etwas anderes wirklich) speichern möchten, müssen Sie sicherstellen, dass die Lebensdauer nicht endet, bevor Sie den Zeiger nicht mehr verwenden. Dies bedeutet, dass Sie wirklich ein benanntes Objekt vom Typ std::function benötigen.

Was im zweiten Fall passiert: Sie erstellen ein temporäres Lambda, das an die Funktion übergeben wird. Da die Funktion eine std::function erwartet, wird eine temporäre std::function aus dem Lambda erstellt. Beide werden am Ende der Linie zerstört werden. Daher haben Sie jetzt einen Zeiger auf ein bereits zerstörtes temporäres Objekt, was bedeutet, dass Sie, wenn Sie versuchen, das Objekt zu verwenden, das Sie als Objekt verwenden, in ein undefiniertes Verhaltensgebiet gelangen.

Answer 2

Es ist in Ordnung für statesless lambdas. Stateless-Lambdas haben eine implizite Umwandlung in den Funktions-Zeigertyp.

Auch gibt es immer eine implizite Konvertierung in std :: Funktion <> unabhängig von der tatsächlichen aufrufbaren Typ.

Es gibt Probleme mit einem Zeiger auf Provisorien, obwohl. Das hatte ich beim ersten Lesen des Codes nicht bemerkt.

Das hat natürlich nichts mit std :: function zu tun.

Answer 3

Temporäre Objekte werden am Ende der Anweisung zerstört, in der sie erstellt wurden. Sie haben dies gerade mit einem Lambda demonstriert.

Die Std-Funktion, die Sie das erste Mal übergeben, ist keine temporäre, also dauert es so lange wie die Variable. Es speichert tatsächlich eine Kopie des temporären.

Um Ihre Lamdas mehr als eine Linie dauern zu lassen, müssen Sie sie irgendwo speichern und ihre Lebensdauer bestimmt haben.

Es gibt viele Möglichkeiten, dies zu tun. Std-Funktion ist eine Art löschungsbasierten Weg, um den Speicher zu tun - dh, speichern Sie eine Std-Funktion anstelle eines Zeigers auf eine Std-Funktion. Ändern Sie den Typ von pointer zu einem Nicht-Zeiger (und nicht const), loswerden &, wenn Sie zuweisen, und rufen Sie es direkt auf.

Im Allgemeinen vermeiden und speichern Sie die Adresse der const Referenzfunktionsparameter als temporäre Bindung an sie, es sei denn, Sie fangen die Rvalue Referenzmöglichkeit in einer anderen Überladung.