Funktion, die einen Lambda-Ausdruck zurückgibt

Ich frage mich, ob es möglich ist, eine Funktion zu schreiben, die eine Lambda-Funktion in C ++ 11 zurückgibt. Ein Problem ist natürlich, wie eine solche Funktion deklariert wird. Jedes Lambda hat einen Typ, aber dieser Typ ist in C ++ nicht ausdrückbar. Ich denke nicht, dass das funktionieren würde:

auto retFun() -> decltype ([](int x) -> int)
{
    return [](int x) { return x; }
}

Noch dies:

int(int) retFun();

Mir sind keine automatischen Konvertierungen von Lambdas in Zeiger auf Funktionen oder ähnliches bekannt. Ist die einzige Lösung, die ein Funktionsobjekt handgefertigt und zurückgibt?

Sie benötigen kein handgefertigtes Funktionsobjekt, sondern verwenden es einfach std::function , in das Lambda-Funktionen konvertierbar sind:

Dieses Beispiel gibt die Ganzzahlidentitätsfunktion zurück:

std::function<int (int)> retFun() {
    return [](int x) { return x; };
}

Für dieses einfache Beispiel brauchen Sie nicht std::function.

Aus dem Standard §5.1.2 / 6:

Der Abschlusstyp für einen Lambda-Ausdruck ohne Lambda-Erfassung verfügt über eine öffentliche nicht virtuelle nicht explizite const-Konvertierungsfunktion für den Zeiger auf eine Funktion mit denselben Parameter- und Rückgabetypen wie der Funktionsaufrufoperator des Abschlusstyps. Der von dieser Konvertierungsfunktion zurückgegebene Wert ist die Adresse einer Funktion, die beim Aufrufen den gleichen Effekt hat wie das Aufrufen des Funktionsaufrufoperators des Schließungstyps.

Da Ihre Funktion keine Erfassung hat, bedeutet dies, dass das Lambda in einen Zeiger auf eine Funktion vom Typ konvertiert werden kann int (*)(int):

typedef int (*identity_t)(int); // works with gcc
identity_t retFun() { 
  return [](int x) { return x; };
}

Das ist mein Verständnis, korrigiere mich, wenn ich falsch liege.

Sie können die Lambda-Funktion von einer anderen Lambda-Funktion zurückgeben, da Sie den Rückgabetyp der Lambda-Funktion nicht explizit angeben sollten. Schreiben Sie einfach so etwas im globalen Bereich:

 auto retFun = []() {
     return [](int x) {return x;};
 };

Obwohl die Frage speziell nach C ++ 11 fragt, erlaubt C ++ 14 für andere, die darauf stoßen und Zugriff auf einen C ++ 14-Compiler haben, jetzt abgeleitete Rückgabetypen für normale Funktionen. Das Beispiel in der Frage kann also so angepasst werden, dass es wie gewünscht funktioniert, indem einfach die -> decltypeKlausel ... nach der Liste der Funktionsparameter gelöscht wird:

auto retFun()
{
    return [](int x) { return x; }
}

Beachten Sie jedoch, dass dies nicht funktioniert, wenn mehr als eine return <lambda>;in der Funktion angezeigt wird. Dies liegt daran, dass eine Einschränkung beim Abzug von Rückgabetypen darin besteht, dass alle Rückgabeanweisungen Ausdrücke desselben Typs zurückgeben müssen, aber jedes Lambda-Objekt vom Compiler einen eigenen eindeutigen Typ erhält, sodass die return <lambda>;Ausdrücke jeweils einen anderen Typ haben.

Sie sollten so schreiben:

auto returnFunction = [](int x){
    return [&x](){
        return x;
    }();
};

um Ihre Rückgabe als Funktion zu erhalten und sie wie folgt zu verwenden:

int val = returnFunction(someNumber);

Wenn Sie nicht über C ++ 11 verfügen und Ihren C ++ - Code beispielsweise auf Mikrocontrollern ausführen. Sie können einen ungültigen Zeiger zurückgeben und dann eine Umwandlung durchführen.

void* functionThatReturnsLambda()
{
    void(*someMethod)();

    // your lambda
    someMethod = []() {

        // code of lambda

    };

    return someMethod;
}


int main(int argc, char* argv[])
{

    void* myLambdaRaw = functionThatReturnsLambda();

    // cast it
    auto myLambda = (void(*)())myLambdaRaw;

    // execute lambda
    myLambda();
}