Funzione che restituisce un'espressione lambda

Mi chiedo se sia possibile scrivere una funzione che restituisce una funzione lambda in C ++ 11. Naturalmente un problema è come dichiarare tale funzione. Ogni lambda ha un tipo, ma quel tipo non è esprimibile in C ++. Non penso che funzionerebbe:

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

Né questo:

int(int) retFun();

Non sono a conoscenza di conversioni automatiche da lambda a, diciamo, puntatori a funzioni o qualcosa del genere. L'unica soluzione è creare manualmente un oggetto funzione e restituirlo?

Non hai bisogno di un oggetto funzione artigianale, basta usare std::function, in cui le funzioni lambda sono convertibili:

Questo esempio restituisce la funzione di identità intera:

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

Per questo semplice esempio, non è necessario std::function.

Dallo standard §5.1.2 / 6:

Il tipo di chiusura per un'espressione lambda senza acquisizione lambda ha una funzione di conversione const pubblica non virtuale non esplicita per puntare a una funzione con gli stessi parametri e tipi restituiti dell'operatore di chiamata di funzione del tipo di chiusura. Il valore restituito da questa funzione di conversione deve essere l'indirizzo di una funzione che, se invocata, ha lo stesso effetto dell'invocazione dell'operatore di chiamata di funzione del tipo di chiusura.

Poiché la tua funzione non ha un'acquisizione, significa che lambda può essere convertito in un puntatore a una funzione di tipo int (*)(int):

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

Questa è la mia comprensione, correggimi se sbaglio.

Puoi restituire la funzione lambda da un'altra funzione lambda, poiché non dovresti specificare esplicitamente il tipo di ritorno della funzione lambda. Basta scrivere qualcosa del genere in ambito globale:

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

Sebbene la domanda chieda specificamente di C ++ 11, per il bene di altri che si imbattono in questo e hanno accesso a un compilatore C ++ 14, C ++ 14 ora consente tipi di ritorno dedotti per funzioni ordinarie. Quindi l'esempio nella domanda può essere regolato solo per funzionare come desiderato semplicemente lasciando cadere la -> decltypeclausola ... dopo l'elenco dei parametri della funzione:

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

Notare, tuttavia, che questo non funzionerà se più di uno return <lambda>;appare nella funzione. Questo perché una restrizione sulla deduzione del tipo restituito è che tutte le istruzioni return devono restituire espressioni dello stesso tipo, ma ogni oggetto lambda riceve il proprio tipo univoco dal compilatore, quindi le return <lambda>;espressioni avranno ciascuna un tipo diverso.

Dovresti scrivere in questo modo:

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

per ottenere il tuo ritorno come funzione e usalo come:

int val = returnFunction(someNumber);

Se non hai c ++ 11 e stai eseguendo il tuo codice c ++ su microcontrollori, ad esempio. Puoi restituire un puntatore vuoto e quindi eseguire un cast.

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