Função que retorna uma expressão lambda

Gostaria de saber se é possível escrever uma função que retorna uma função lambda em C ++ 11. Claro, um problema é como declarar tal função. Cada lambda tem um tipo, mas esse tipo não pode ser expresso em C ++. Eu não acho que isso funcionaria:

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

Nem este:

int(int) retFun();

Não estou ciente de nenhuma conversão automática de lambdas para, digamos, ponteiros para funções ou algo parecido. A única solução é criar um objeto de função manualmente e devolvê-lo?

Você não precisa de um objeto de função artesanal, apenas use std::function, para o qual as funções lambda são conversíveis:

Este exemplo retorna a função de identidade de inteiro:

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

Para este exemplo simples, você não precisa std::function.

Do padrão §5.1.2 / 6:

O tipo de fechamento para um lambda-expressão sem lambda-captura tem uma função pública não-virtual não explícita conversão const para ponteiro para função de ter os mesmos tipos de parâmetro e retorno como operador de chamada de função do tipo de fechamento. O valor retornado por esta função de conversão deve obrigatoriamente ser o endereço de uma função que, quando invocada, tem o mesmo efeito que invocar o operador de chamada de função do tipo de encerramento.

Como sua função não tem uma captura, isso significa que o lambda pode ser convertido em um ponteiro para função do tipo int (*)(int):

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

Esse é o meu entendimento, corrija-me se eu estiver errado.

Você pode retornar a função lambda de outra função lambda, já que não deve especificar explicitamente o tipo de retorno da função lambda. Basta escrever algo assim em escopo global:

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

Embora a questão pergunte especificamente sobre C ++ 11, para o bem de outras pessoas que se deparam com isso e têm acesso a um compilador C ++ 14, C ++ 14 agora permite tipos de retorno deduzidos para funções comuns. Portanto, o exemplo em questão pode ser ajustado apenas para funcionar conforme desejado, simplesmente descartando a -> decltypecláusula ... após a lista de parâmetros de função:

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

Observe, entretanto, que isso não funcionará se mais de um return <lambda>;aparecer na função. Isso ocorre porque uma restrição na dedução do tipo de retorno é que todas as instruções de retorno devem retornar expressões do mesmo tipo, mas cada objeto lambda recebe seu próprio tipo exclusivo pelo compilador, portanto return <lambda>;, cada expressão terá um tipo diferente.

Você deve escrever assim:

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

para obter seu retorno como uma função e usá-lo como:

int val = returnFunction(someNumber);

Se você não tiver o c ++ 11 e estiver executando seu código c ++ em micro controladores, por exemplo. Você pode retornar um ponteiro vazio e, em seguida, executar uma conversão.

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