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

Question

yo estaba tratando de crear un vector de lambda, pero fracasaron:

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

hasta la línea # 2, que compiles fine. Pero la línea # 3 da compilation error:

error: no matching function for call to 'std::vector<main()::<lambda()>>::push_back(main()::<lambda()>)'

no quiero un vector de punteros a funciones o vector de objetos de función. Sin embargo, el vector de los objetos de función que encapsula real expresiones lambda, me funcionaría. es posible?

Answer 1

Cada lambda tiene un tipo diferente —, incluso si tienen la misma firma. Debe usar un contenedor de encapsulamiento en tiempo de ejecución como std::function si desea hacer algo como eso.

ej .:

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

I don't want a vector of function pointers or vector of function objects.

Bueno, me gustaría un buen trabajo que paga con un equipo de desarrolladores de cien personas para desarrollar todos mis sueños, pero eso no va a suceder, ya sea. No siempre puedes obtener lo que quieres.

Answer 2

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

One solution es hacer un vector de std::function<int()> en su lugar.

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

Por otro lado, no es una buena idea usar [&] cuando no se está capturando cualquier cosa.

Answer 3

Si su lambda no tiene estado, es decir, [](...){...}, C++ 11 le permite degradarse a un puntero de función. En teoría, un compilador compatible con C++ 11 sería capaz de compilar esta:

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

Answer 4

Si bien lo que han dicho que es relevante, todavía es posible declarar y utilizar un vector de lambda, aunque no es muy útil :

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

por lo tanto, puede almacenar cualquier número de lambdas allí, siempre y cuando sea una copia/movimiento de lambda!

Answer 5

Cada lambda es de un tipo diferente. Debe usar std::tuple en lugar de std::vector.

Answer 6

se puede utilizar una función de generación de lambda (actualizado con la solució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, hizo su propia clase en este punto. De lo contrario, si las lambdas tienen caputres/args completamente diferentes, es probable que tengas que usar una tupla.