¿Por qué no puedo crear un vector de lambdas (del mismo tipo) en C ++ 11?

Estaba tratando de crear un vector de lambda, pero fallé:

auto ignore = [&]() { return 10; };  //1
std::vector<decltype(ignore)> v;     //2
v.push_back([&]() { return 100; });  //3

Hasta la línea 2, se compila bien . Pero la línea # 3 da error de compilación :

error: no hay función coincidente para llamar a 'std :: vector <main () :: <lambda () >> :: push_back (main () :: <lambda ()>)'

No quiero un vector de punteros de función o un vector de objetos de función. Sin embargo, el vector de objetos de función que encapsulan expresiones lambda reales funcionaría para mí. es posible?

Cada lambda tiene un tipo diferente, incluso si tienen la misma firma. Debe usar un contenedor de encapsulación en tiempo de ejecución, por ejemplo, std::functionsi desea hacer algo así.

p.ej:

std::vector<std::function<int()>> functors;
functors.push_back([&] { return 100; });
functors.push_back([&] { return  10; });

Todas las expresiones lambda tienen un tipo diferente, incluso si son idénticas carácter por carácter . Estás empujando una lambda de un tipo diferente (porque es otra expresión) en el vector, y eso obviamente no funcionará.

Una solución es hacer un vector de en su std::function<int()>lugar.

auto ignore = [&]() { return 10; };
std::vector<std::function<int()>> v;
v.push_back(ignore);
v.push_back([&]() { return 100; });

En otra nota, no es una buena idea usarlo [&]cuando no está capturando nada.

Si bien lo que otros han dicho es relevante, aún es posible declarar y usar un vector de lambda, aunque no es muy útil:

auto lambda = [] { return 10; };
std::vector<decltype(lambda)> vec;
vec.push_back(lambda);

Por lo tanto, puede almacenar cualquier cantidad de lambdas allí, ¡siempre que sea una copia / movimiento de lambda!

Si su lambda no tiene estado, es decir, [](...){...}C ++ 11 permite que se degrade en un puntero de función. En teoría, un compilador compatible con C ++ 11 podría compilar esto:

auto ignore = []() { return 10; };  //1 note misssing & in []!
std::vector<int (*)()> v;     //2
v.push_back([]() { return 100; });  //3

Puede usar una función de generación de lambda (actualizada con la corrección sugerida por Nawaz):

#include <vector>
#include <iostream>

int main() {
    auto lambda_gen = [] (int i) {return [i](int x){ return i*x;};} ;

    using my_lambda = decltype(lambda_gen(1));

    std::vector<my_lambda> vec;

    for(int i = 0; i < 10; i++) vec.push_back(lambda_gen(i));

    int i = 0;

    for (auto& lambda : vec){
        std::cout << lambda(i) << std::endl;
        i++;
    }
}

Pero creo que básicamente hiciste tu propia clase en este momento. De lo contrario, si las lambdas tienen caputres / args completamente diferentes, etc., probablemente tenga que usar una tupla.

Cada lambda es de un tipo diferente. Debe utilizar en std::tuplelugar de std::vector.