Fonction renvoyant une expression lambda

Je me demande s'il est possible d'écrire une fonction qui renvoie une fonction lambda en C ++ 11. Bien sûr, un problème est de savoir comment déclarer une telle fonction. Chaque lambda a un type, mais ce type n'est pas exprimable en C ++. Je ne pense pas que cela fonctionnerait:

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

Ni ceci:

int(int) retFun();

Je ne suis pas au courant de conversions automatiques de lambdas en, par exemple, des pointeurs vers des fonctions, ou quelque chose du genre. La seule solution est-elle de fabriquer à la main un objet de fonction et de le renvoyer?

Vous n'avez pas besoin d'un objet de fonction fabriqué à la main, utilisez simplement std::function, vers lequel les fonctions lambda sont convertibles:

Cet exemple renvoie la fonction d'identité entière:

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

Pour cet exemple simple, vous n'avez pas besoin de std::function.

À partir du §5.1.2 / 6 standard:

Le type de fermeture pour un lambda-expression sans lambda-capture a un non explicite public non virtuelle fonction de conversion de const pointeur vers une fonction ayant les mêmes paramètres et types de retour comme opérateur d'appel de fonction du type de fermeture. La valeur renvoyée par cette fonction de conversion doit être l'adresse d'une fonction qui, lorsqu'elle est invoquée, a le même effet que l'appel de l'opérateur d'appel de fonction du type de fermeture.

Étant donné que votre fonction n'a pas de capture, cela signifie que le lambda peut être converti en un pointeur vers une fonction de type int (*)(int):

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

C'est ce que je comprends, corrigez-moi si je me trompe.

Vous pouvez renvoyer une fonction lambda à partir d'une autre fonction lambda, car vous ne devez pas spécifier explicitement le type de retour de la fonction lambda. Écrivez simplement quelque chose comme ça dans une portée globale:

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

Bien que la question porte spécifiquement sur C ++ 11, pour le bien des autres qui trébuchent sur cela et ont accès à un compilateur C ++ 14, C ++ 14 permet maintenant des types de retour déduits pour les fonctions ordinaires. Ainsi, l'exemple de la question peut être ajusté juste pour fonctionner comme vous le souhaitez en supprimant simplement la -> decltypeclause ... après la liste des paramètres de la fonction:

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

Notez, cependant, que cela ne fonctionnera pas si plus d'un return <lambda>;apparaît dans la fonction. En effet, une restriction sur la déduction du type de retour est que toutes les instructions de retour doivent renvoyer des expressions du même type, mais chaque objet lambda reçoit son propre type unique par le compilateur, de sorte que les return <lambda>;expressions auront chacune un type différent.

Vous devriez écrire comme ceci:

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

pour obtenir votre retour en tant que fonction, et utilisez-le comme:

int val = returnFunction(someNumber);

Si vous n'avez pas c ++ 11 et exécutez votre code C ++ sur des micro-contrôleurs par exemple. Vous pouvez renvoyer un pointeur vide, puis effectuer une distribution.

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