Was ist die Lebensdauer eines C ++ - Lambda-Ausdrucks?

(Ich habe bereits gelesen, wie lange implizite Funktoren aus Lambda in C ++ noch leben, und diese Frage wird nicht beantwortet.)

Ich verstehe, dass die C ++ - Lambda-Syntax nur Zucker ist, um eine Instanz einer anonymen Klasse mit einem Aufrufoperator und einem bestimmten Status zu erstellen, und ich verstehe die Lebensdaueranforderungen dieses Status (entschieden, ob Sie nach dem Wert von als Referenz erfassen). Aber was ist die Lebensdauer des Lambda-Objekts selbst? std::functionWird die zurückgegebene Instanz im folgenden Beispiel nützlich sein?

std::function<int(int)> meta_add(int x) {
    auto add = [x](int y) { return x + y; };
    return add;
}

Wenn ja, wie funktioniert es ? Das scheint mir ein bisschen zu magisch zu sein - ich kann mir nur vorstellen, dass es funktioniert, wenn std::functionich meine gesamte Instanz kopiere, was je nach dem, was ich aufgenommen habe, sehr schwer sein kann - in der Vergangenheit habe ich std::functionhauptsächlich mit bloßen Funktionszeigern verwendet und diese kopiert schnell. Es scheint auch angesichts der std::functionArt der Löschung problematisch zu sein .

Die Lebensdauer ist genau so, wie es wäre, wenn Sie Ihr Lambda durch einen handgerollten Funktor ersetzen würden:

struct lambda {
   lambda(int x) : x(x) { }
   int operator ()(int y) { return x + y; }

private:
   int x;
};

std::function<int(int)> meta_add(int x) {
   lambda add(x);
   return add;
}

Das Objekt wird lokal für die meta_addFunktion erstellt und dann [in seiner Gesamtheit, einschließlich des Werts von x] in den Rückgabewert verschoben. Dann verlässt die lokale Instanz den Gültigkeitsbereich und wird wie gewohnt zerstört. Das von der Funktion zurückgegebene Objekt bleibt jedoch so lange gültig wie das std::functionObjekt, das es enthält. Wie lange das dauert, hängt natürlich vom aufrufenden Kontext ab.

Es scheint, dass Sie verwirrter sind std::functionals Lambdas.

std::functionverwendet eine Technik namens Typlöschung. Hier ist ein kurzer Vorbeiflug.

class Base
{
  virtual ~Base() {}
  virtual int call( float ) =0;
};

template< typename T>
class Eraser : public Base
{
public:
   Eraser( T t ) : m_t(t) { }
   virtual int call( float f ) override { return m_t(f); }
private:
   T m_t;
};

class Erased
{
public:
   template<typename T>
   Erased( T t ) : m_erased( new Eraser<T>(t) ) { }

   int do_call( float f )
   {
      return m_erased->call( f );
   }
private:
   Base* m_erased;
};

Warum sollten Sie den Typ löschen wollen? Ist das nicht der Typ, den wir wollen int (*)(float)?

Durch das Löschen des Typs Erasedkann jetzt jeder aufrufbare Wert gespeichert werden int(float).

int boring( float f);
short interesting( double d );
struct Powerful
{
   int operator() ( float );
};

Erased e_boring( &boring );
Erased e_interesting( &interesting );
Erased e_powerful( Powerful() );
Erased e_useful( []( float f ) { return 42; } );

Das ist:

[x](int y) { return x + y; };

Ist gleichbedeutend mit: (oder kann auch berücksichtigt werden)

struct MyLambda
{
    MyLambda(int x): x(x) {}
    int operator()(int y) const { return x + y; }
private:
    int x;
};

Ihr Objekt gibt also ein Objekt zurück, das genau so aussieht. Welches hat einen gut definierten Kopierkonstruktor. Es erscheint daher sehr vernünftig, dass es korrekt aus einer Funktion kopiert werden kann.

In dem Code, den Sie gepostet haben:

std::function<int(int)> meta_add(int x) {
    auto add = [x](int y) { return x + y; };
    return add;
}

Das std::function<int(int)>von der Funktion zurückgegebene Objekt enthält tatsächlich eine verschobene Instanz des Lambda-Funktionsobjekts, das der lokalen Variablen zugewiesen wurde add.

Wenn Sie ein C ++ 11-Lambda definieren, das nach Wert oder nach Referenz erfasst, generiert der C ++ - Compiler automatisch einen eindeutigen Funktionstyp, dessen Instanz erstellt wird, wenn das Lambda aufgerufen oder einer Variablen zugewiesen wird. Zur Veranschaulichung generiert Ihr C ++ - Compiler möglicherweise den folgenden Klassentyp für das Lambda, definiert durch [x](int y) { return x + y; }:

class __lambda_373s27a
{
    int x;

public:
    __lambda_373s27a(int x_)
        : x(x_)
    {
    }

    int operator()(int y) const {
        return x + y;
    }
};

Dann ist die meta_addFunktion im Wesentlichen äquivalent zu:

std::function<int(int)> meta_add(int x) {
    __lambda_373s27a add = __lambda_373s27a(x);
    return add;
}

EDIT: Ich bin mir übrigens nicht sicher, ob Sie das wissen, aber dies ist ein Beispiel für das Currying von Funktionen in C ++ 11.