Warum funktioniert eine lambda haben eine Größe von 1 byte?

Die lambda in Frage, hat eigentlich kein Staat.

Untersuchen:

struct lambda {
  auto operator()() const { return 17; }
};

Und wenn wir hatten lambda f; es ist eine leere Klasse. Nicht nur die oben lambda funktional ähnlich lambda, es ist (im Grunde), wie Ihre lambda-Ausdruck implementiert! (Es braucht auch eine implizite cast-Funktion-Zeiger-operator und dem Namen lambda wird ersetzt mit einigen compiler-generierten pseudo-guid)

In C++, Objekte sind keine Zeiger. Sie sind die eigentlichen Dinge. Benutzen Sie nur den Raum benötigt zum speichern von Daten, die in Ihnen. Ein Zeiger auf ein Objekt kann größer sein als ein Objekt.

Während Sie vielleicht denken, dass lambda als ein Zeiger auf eine Funktion, ist es nicht. Sie können nicht zuweisen, die auto f = [](){ return 17; }; auf eine andere Funktion oder lambda!

 auto f = [](){ return 17; };
 f = [](){ return -42; };

oben ist illegale. Es gibt keine Zimmer im f zu speichern die Funktion genannt wird -, dass Informationen gespeichert werden Typ von f, nicht im Wert von f!

Wenn du das getan hast:

int(*f)() = [](){ return 17; };

oder so:

std::function<int()> f = [](){ return 17; };

sind Sie nicht mehr die Speicherung der lambda direkt. In beiden Fällen f = [](){ return -42; } legal ist -- so dass in diesen Fällen speichern wir die Funktion, die wir aufrufen im Wert von f. Und sizeof(f) ist nicht mehr 1, sondern sizeof(int(*)()) oder größer (im Grunde, werden Zeiger Größe oder größer, als Sie erwarten. std::function hat eine min Größe implizit die standard - (Sie müssen in der Lage sein, zu speichern, "in sich selbst" callables bis zu einer bestimmten Größe), die mindestens so groß ist wie ein Funktionszeiger in der Praxis).

In der int(*f)() Fall, den Sie speichern einen Funktionszeiger auf eine Funktion, die sich so verhält, wie-wenn man angerufen, dass die lambda. Dies funktioniert nur für zustandslose lambdas (mit einer leeren [] capture-Liste).

In der std::function<int()> f Fall, erstellen Sie ein type-erasure-Klasse std::function<int()> Instanz (in diesem Fall) verwendet, die Platzierung neuer zum speichern einer Kopie der Größe-1 lambda in einem internen Puffer (und, wenn ein größeres lambda-Ausdruck übergeben wurde (mit mehr Staat) nutzen würde, heap allocation).

Als eine Vermutung, so etwas wie dies ist wahrscheinlich das, was Sie denken, ist passiert. Das lambda ist ein Objekt, dessen Typ wird beschrieben durch Ihre Signatur. In C++, es war entschieden, um lambdas null-Kosten Abstraktionen über die manuelle Funktion-Objekt-Implementierung. Dadurch können Sie an einem lambda-Ausdruck in eine std Algorithmus (oder ähnlich) und haben seinen Inhalt vollständig sichtbar, der compiler, wenn es instanziiert wird, der Algorithmus Vorlage. Wenn eine lambda hatte einen Typ wie std::function<void(int)>, der Inhalt würde nicht vollständig sichtbar ist, und einem handgefertigten Objekt Funktion könnte schneller sein.

Dem Ziel der C++ - Standardisierung ist die high-level-Programmierung mit null-overhead-über-hand-crafted C-code.

Nun, dass Sie verstehen, dass Ihre f ist in der Tat staatenlos, sollte es eine weitere Frage in Ihrem Kopf: der lambda-Ausdruck hat keinen Staat. Warum macht es nicht die Größe haben 0?

Es ist die kurze Antwort.

Alle Objekte in C++ muss ein minimium Größe von 1, unter dem standard, und zwei Objekte den gleichen Typ haben, kann nicht die gleiche Adresse. Diese sind miteinander verbunden, weil ein array vom Typ T werden die Elemente platziert sizeof(T) auseinander.

Nun, da es keine Staatliche, manchmal kann es dauern, bis keinen Platz. Dies kann nicht passieren, wenn es "allein", aber in manchen Kontexten kann es passieren. std::tuple und ähnliche code-Bibliothek nutzt diese Tatsache. Hier ist, wie es funktioniert:

Als ein lambda-Ausdruck ist äquivalent zu einer Klasse mit operator() überlastet, zustandslose lambdas (mit einem [] capture-Liste) sind alle leeren Klassen. Sie haben sizeof von 1. In der Tat, wenn Sie Erben von Ihnen (was zulässig ist!), Sie nehmen keinen Platz so lange, wie es nicht zu einer gleichen-Typ-Adresse Kollision. (Dies ist bekannt als die leeren sockel-Optimierung).

template<class T>
struct toy:T {
  toy(toy const&)=default;
  toy(toy &&)=default;
  toy(T const&t):T(t) {}
  toy(T &&t):T(std::move(t)) {}
  int state = 0;
};

template<class Lambda>
toy<Lambda> make_toy( Lambda const& l ) { return {l}; }

den sizeof(make_toy( []{std::cout << "hello world!\n"; } )) ist sizeof(int) (gut, das oben ist illegal, weil Sie können nicht erstellen Sie einen lambda-Ausdruck in eine nicht ausgewertet Zusammenhang: Sie haben zum erstellen einer benannten auto toy = make_toy(blah); dann tun sizeof(blah), aber das ist nur Lärm). sizeof([]{std::cout << "hello world!\n"; }) noch 1 (vergleichbare Qualifikation).

Wenn wir ein anderes Spielzeug Typ:

template<class T>
struct toy2:T {
  toy2(toy2 const&)=default;
  toy2(T const&t):T(t), t2(t) {}
  T t2;
};
template<class Lambda>
toy2<Lambda> make_toy2( Lambda const& l ) { return {l}; }

dieser hat zwei Kopien von lambda. Denn Sie können nicht die gleiche Adresse, sizeof(toy2(some_lambda)) ist 2!

Dem compiler mehr oder weniger übersetzt, die den lambda-Ausdruck die folgende struct-Typ:

struct _SomeInternalName {
    int operator()() { return 17; }
};

int main()
{
     _SomeInternalName f;
     std::cout << f() << std::endl;
}

Da, die struct hat keine nicht-statischen Elemente, es hat die gleiche Größe wie eine leere Struktur, die 1.

Dass ändert sich, sobald Sie eine nicht-leere capture-Liste um deine lambda:

int i = 42;
auto f = [i]() { return i; };

Die übersetzen

struct _SomeInternalName {
    int i;
    _SomeInternalName(int outer_i) : i(outer_i) {}
    int operator()() { return i; }
};


int main()
{
     int i = 42;
     _SomeInternalName f(i);
     std::cout << f() << std::endl;
}

Da die erzeugte Struktur muss nun speichern Sie eine nicht-statische int Mitglied für die Erfassung, seine Größe zu wachsen, um sizeof(int). Die Größe wird weiter wachsen, wie Sie erfassen mehr Zeug.

(Bitte nehmen Sie sich die Struktur-Analogie mit einem Körnchen Salz. Es ist zwar ein schöner Weg, sich Gedanken darüber zu machen, wie Lambda-Ausdrücke intern arbeiten, ist dies nicht eine wörtliche übersetzung von dem, was der compiler tun wird)

Vom http://en.cppreference.com/w/cpp/language/lambda:

Den lambda-Ausdruck konstruiert eine Unbenannte prvalue temporären Objekt der einzigartigen Unbenannte non-union nicht-Aggregat-Klasse Typ, bekannt als Verschluss Typ, was erklärt wird (für die Zwecke ADL) in den kleinsten block scope, Klasse Rahmen, oder namespace-Gültigkeitsbereich enthält, die den lambda-Ausdruck.

Wenn die lambda-Ausdruck erfasst alles, was von kopieren (entweder implizit mit capture-Klausel [=] oder explizit mit erfassen, die nicht das Zeichen &, z.B. [a, b, c]), Verschluss-Typ enthält Unbenannte nicht-statischen Daten-member, erklärt, in unbekannter Reihenfolge, dass die Kopien alle Entitäten, die waren so gefangen.

Für die Personen, die erfasst, die durch Verweis (mit der Standard-capture - [&] oder, wenn Sie das Zeichen &, z.B. [&a &b &c]), ist es unspezifisch, wenn zusätzliche Daten-member deklariert sind im Verschluss Typ

Vom http://en.cppreference.com/w/cpp/language/sizeof

Bei der Anwendung auf eine leere Klasse Typ, gibt immer 1 zurück.