Perché non posso creare un vettore di lambda (dello stesso tipo) in C ++ 11?

Stavo cercando di creare un vettore di lambda, ma non è riuscito:

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

Fino alla riga # 2, si compila bene . Ma la riga # 3 dà un errore di compilazione :

errore: nessuna funzione corrispondente per la chiamata a 'std :: vector <main () :: <lambda () >> :: push_back (main () :: <lambda ()>)'

Non voglio un vettore di puntatori a funzione o un vettore di oggetti funzione. Tuttavia, il vettore di oggetti funzione che incapsulano espressioni lambda reali , funzionerebbe per me. È possibile?

Ogni lambda ha un tipo diverso, anche se ha la stessa firma. È necessario utilizzare un contenitore incapsulante in fase di esecuzione, ad esempio std::functionse si desidera eseguire un'operazione del genere.

per esempio:

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

Tutte le espressioni lambda hanno un tipo diverso, anche se sono identiche carattere per carattere . Stai inserendo un lambda di un tipo diverso (perché è un'altra espressione) nel vettore e ovviamente non funzionerà.

Una soluzione è invece creare un vettore std::function<int()>.

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

In un'altra nota, non è una buona idea usare [&]quando non stai catturando nulla.

Sebbene ciò che altri hanno detto sia rilevante, è ancora possibile dichiarare e utilizzare un vettore di lambda, sebbene non sia molto utile:

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

Quindi, puoi memorizzare un numero qualsiasi di lambda lì, purché sia ​​una copia / mossa di lambda!

Se il tuo lambda è senza stato, cioè, [](...){...}C ++ 11 gli consente di degradarsi in un puntatore a funzione. In teoria, un compilatore conforme a C ++ 11 sarebbe in grado di compilare questo:

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

È possibile utilizzare una funzione di generazione lambda (aggiornata con la correzione suggerita da 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++;
    }
}

Ma penso che tu abbia praticamente creato la tua lezione a questo punto. Altrimenti se i lambda hanno caputres / args ecc. Completamente diversi, probabilmente dovrai usare una tupla.

Ogni lambda è di un tipo diverso. Devi usare std::tupleinvece di std::vector.