Lambda fungiert als Basisklasse
Als ich mit Lambdas herumspielte, fand ich ein interessantes Verhalten, das ich nicht ganz verstehe.
Angenommen, ich habe einestruct Overload
Das ergibt sich aus 2 Template-Parametern und hat eineusing F1::operator();
Klausel.
Wenn ich nun von zwei Funktoren abstamme, kann ich nur auf den Operator () von F1 zugreifen (wie ich es erwarten würde)
Wenn ich von zwei Lambda-Funktionen abstamme, ist dies nicht mehr wahr: Ich kann auch über F2 auf den Operator () zugreifen.
#include <iostream>
// I compiled with g++ (GCC) 4.7.2 20121109 (Red Hat 4.7.2-8)
//
// g++ -Wall -std=c++11 -g main.cc
// g++ -Wall -std=c++11 -DFUNCTOR -g main.cc
//
// or clang clang version 3.3 (tags/RELEASE_33/rc2)
//
// clang++ -Wall -std=c++11 -g main.cc
// clang++ -Wall -std=c++11 -DFUNCTOR -g main.cc
//
// on a Linux localhost.localdomain 3.9.6-200.fc18.i686 #1 SMP Thu Jun 13
// 19:29:40 UTC 2013 i686 i686 i386 GNU/Linux box
struct Functor1
{
void operator()() { std::cout << "Functor1::operator()()\n"; }
};
struct Functor2
{
void operator()(int) { std::cout << "Functor2::operator()(int)\n"; }
};
template <typename F1, typename F2>
struct Overload : public F1, public F2
{
Overload()
: F1()
, F2() {}
Overload(F1 x1, F2 x2)
: F1(x1)
, F2(x2) {}
using F1::operator();
};
template <typename F1, typename F2>
auto get(F1 x1, F2 x2) -> Overload<F1, F2>
{
return Overload<F1, F2>(x1, x2);
}
int main(int argc, char *argv[])
{
auto f = get(Functor1(), Functor2());
f();
#ifdef FUNCTOR
f(2); // this one doesn't work IMHO correctly
#endif
auto f1 = get(
[]() { std::cout << "lambda1::operator()()\n"; },
[](int) { std::cout << "lambda2::operator()(int)\n"; }
);
f1();
f1(2); // this one works but I don't know why
return 0;
}
Der Standard besagt, dass:
Der Typ des Lambda-Ausdrucks (der auch der Typ des Closure-Objekts ist) ist ein eindeutiger, unbenannter Nicht-Union-Klassentyp
So sollte jeder Lambda-Typ einzigartig sein.
Ich kann nicht erklären, warum das so ist: Kann jemand bitte etwas Licht ins Dunkel bringen?