Por que não consigo criar um vetor de lambdas (do mesmo tipo) em C ++ 11?

Eu estava tentando criar um vetor de lambda, mas falhou:

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

Até a linha 2, ele compila perfeitamente . Mas a linha 3 fornece erro de compilação :

erro: nenhuma função correspondente para chamada para 'std :: vector <main () :: <lambda () >> :: push_back (main () :: <lambda ()>)'

Não quero um vetor de ponteiros de função ou vetor de objetos de função. No entanto, o vetor de objetos de função que encapsulam expressões lambda reais funcionaria para mim. Isso é possível?

Cada lambda tem um tipo diferente - mesmo se eles tiverem a mesma assinatura. Você deve usar um contêiner de encapsulamento de tempo de execução, como std::functionse você quiser fazer algo assim.

por exemplo:

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

Todas as expressões lambda têm um tipo diferente, mesmo se forem idênticas caractere por caractere . Você está colocando um lambda de um tipo diferente (porque é outra expressão) no vetor e isso obviamente não funcionará.

Uma solução é criar um vetor de std::function<int()>.

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

Por outro lado, não é uma boa ideia usar [&]quando você não está capturando nada.

Embora o que outros disseram seja relevante, ainda é possível declarar e usar um vetor de lambda, embora não seja muito útil:

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

Portanto, você pode armazenar qualquer número de lambdas lá, contanto que seja uma cópia / movimentação de lambda!

Se seu lambda não tem estado, ou seja, [](...){...}C ++ 11 permite que ele se transforme em um ponteiro de função. Em teoria, um compilador compatível com C ++ 11 seria capaz de compilar isso:

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

Você pode usar uma função de geração de lambda (atualizada com a correção 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++;
    }
}

Mas acho que você basicamente fez sua própria aula neste momento. Caso contrário, se os lambdas tiverem caputres / args completamente diferentes, etc., você provavelmente terá que usar uma tupla.

Cada lambda é um tipo diferente. Você deve usar em std::tuplevez de std::vector.