Warum kann ich in C ++ 11 keinen Lambdas-Vektor (desselben Typs) erstellen?

Ich habe versucht, einen Lambda-Vektor zu erstellen, bin aber gescheitert:

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

Bis zu Zeile 2 wird es gut kompiliert . Die Zeile 3 gibt jedoch einen Kompilierungsfehler aus :

Fehler: Keine Übereinstimmungsfunktion für den Aufruf von 'std :: vector <main () :: <lambda () >> :: push_back (main () :: <lambda ()>)'

Ich möchte keinen Vektor von Funktionszeigern oder einen Vektor von Funktionsobjekten. Ein Vektor von Funktionsobjekten, die echte Lambda-Ausdrücke einkapseln , würde jedoch für mich funktionieren. Ist das möglich?

Jedes Lambda hat einen anderen Typ - auch wenn es dieselbe Signatur hat. Sie müssen einen Laufzeit-Kapselungscontainer verwenden, z. B. std::functionwenn Sie so etwas tun möchten.

z.B:

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

Alle Lambda-Ausdrücke haben einen anderen Typ, auch wenn sie zeichenweise identisch sind . Sie schieben ein Lambda eines anderen Typs (weil es ein anderer Ausdruck ist) in den Vektor, und das funktioniert offensichtlich nicht.

Eine Lösung besteht darin, std::function<int()>stattdessen einen Vektor zu erstellen.

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

Außerdem ist es keine gute Idee, sie zu verwenden, [&]wenn Sie nichts erfassen.

Während das, was andere gesagt haben, relevant ist, ist es immer noch möglich, einen Lambda-Vektor zu deklarieren und zu verwenden, obwohl dies nicht sehr nützlich ist:

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

Sie können also eine beliebige Anzahl von Lambdas darin aufbewahren, solange es sich um eine Kopie / Bewegung handelt lambda!

Wenn Ihr Lambda zustandslos ist, dh in [](...){...}C ++ 11, kann es in einen Funktionszeiger umgewandelt werden. Theoretisch könnte ein C ++ 11-kompatibler Compiler dies kompilieren:

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

Sie könnten eine Lambda-Generierungsfunktion verwenden (aktualisiert mit dem von Nawaz vorgeschlagenen Fix):

#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++;
    }
}

Aber ich denke, Sie haben zu diesem Zeitpunkt im Grunde Ihre eigene Klasse gemacht. Andernfalls müssen Sie wahrscheinlich ein Tupel verwenden, wenn die Lambdas völlig unterschiedliche Caputres / Args usw. haben.

Jedes Lambda ist ein anderer Typ. Sie müssen std::tupleanstelle von verwenden std::vector.