Lambda expressions (since C++11)

Konstruiert einen Closure (ein unbenanntes Funktionsobjekt, das Variablen im Gültigkeitsbereich erfassen kann).

Syntax

Lambda-Ausdrücke ohne explizite Template-Parameterliste (möglicherweise nicht generisch)

Lambda-Ausdrücke mit einer expliziten Template-Parameterliste (immer generisch) (seit C++20)

Erklärung

Eine Variable __func__ wird implizit am Anfang des Funktionskörpers definiert, mit der Semantik wie hier beschrieben.

Closure-Typ

Der Lambda-Ausdruck ist ein prvalue-Ausdruck eines eindeutigen unbenannten Nicht- union Nicht- aggregate Klassentyps, bekannt als closure type , der (für die Zwecke von ADL ) im kleinsten Blockbereich, Klassenbereich oder Namensraumbereich deklariert wird, der den Lambda-Ausdruck enthält.

Der Closure-Typ hat die folgenden Member, sie können nicht explizit instanziiert , explizit spezialisiert , oder (seit C++14) in einer Friend-Deklaration benannt werden:

// generic lambda, operator() is a template with two parameters
auto glambda = [](auto a, auto&& b) { return a < b; };
bool b = glambda(3, 3.14); // OK
// generic lambda, operator() is a template with one parameter
auto vglambda = [](auto printer)
{
    return [=](auto&&... ts) // generic lambda, ts is a parameter pack
    { 
        printer(std::forward<decltype(ts)>(ts)...);
        // nullary lambda (takes no parameters):
        return [=] { printer(ts...); };
    };
};
auto p = vglambda([](auto v1, auto v2, auto v3)
{
    std::cout << v1 << v2 << v3;
});
auto q = p(1, 'a', 3.14); // outputs 1a3.14
q();                      // outputs 1a3.14

// generic lambda, operator() is a template with two parameters
auto glambda = []<class T>(T a, auto&& b) { return a < b; };
// generic lambda, operator() is a template with one parameter pack
auto f = []<typename... Ts>(Ts&&... ts)
{
    return foo(std::forward<Ts>(ts)...);
};

struct X
{
    int x, y;
    int operator()(int);
    void f()
    {
        // Der Kontext des folgenden Lambda-Ausdrucks ist die Memberfunktion X::f
        [=]() -> int
        {
            return operator()(this->x + y); // X::operator()(this->x + (*this).y)
                                            // this hat den Typ X*
        };
    }
};

1. ↑ Obwohl die Funktionsrückgabetyp-Deduktion in C++14 eingeführt wurde, ist ihre Regel für die Lambda-Rückgabetyp-Deduktion in C++11 verfügbar.

void f1(int (*)(int)) {}
void f2(char (*)(int)) {}
void h(int (*)(int)) {}  // #1
void h(char (*)(int)) {} // #2
auto glambda = [](auto a) { return a; };
f1(glambda); // OK
f2(glambda); // Fehler: nicht konvertierbar
h(glambda);  // OK: ruft #1 auf, da #2 nicht konvertierbar ist
int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; }; // OK

auto Fwd = [](int(*fp)(int), auto a) { return fp(a); };
auto C = [](auto a) { return a; };
static_assert(Fwd(C, 3) == 3);  // OK
auto NC = [](auto a) { static int s; return a; };
static_assert(Fwd(NC, 3) == 3); // error: no specialization can be
                                // constexpr because of static s

Lambda-Capture

Die captures definieren die externen Variablen, die innerhalb des Lambda-Funktionskörpers zugänglich sind. Ihre Syntax wird wie folgt definiert:

Die Syntax von capture ist wie folgt definiert:

Wenn der capture-default als & festgelegt ist, dürfen nachfolgende einfache Captures nicht mit & beginnen.

struct S2 { void f(int i); };
void S2::f(int i)
{
    [&] {};          // OK: Standardmäßige Erfassung per Referenz
    [&, i] {};       // OK: Erfassung per Referenz, außer i wird als Kopie erfasst
    [&, &i] {};      // Fehler: Erfassung per Referenz, wenn Referenz bereits Standard ist
    [&, this] {};    // OK, äquivalent zu [&]
    [&, this, i] {}; // OK, äquivalent zu [&, i]
}

Wenn die capture-default = ist, müssen nachfolgende einfache Captures mit & beginnen oder *this sein (seit C++17) oder this sein (seit C++20) .

struct S2 { void f(int i); };
void S2::f(int i)
{
    [=] {};        // OK: Standardmäßige Kopiererfassung
    [=, &i] {};    // OK: Kopiererfassung, außer i wird per Referenz erfasst
    [=, *this] {}; // bis C++17: Fehler: Ungültige Syntax
                   // seit C++17: OK: Erfasst das umschließende S2 durch Kopie
    [=, this] {};  // bis C++20: Fehler: this bei = als Standard
                   // seit C++20: OK, identisch mit [=]
}

Jede Erfassung darf nur einmal erscheinen und ihr Name muss sich von jedem Parameternamen unterscheiden:

struct S2 { void f(int i); };
void S2::f(int i)
{
    [i, i] {};        // Fehler: i wiederholt
    [this, *this] {}; // Fehler: "this" wiederholt (C++17)
    [i] (int i) {};   // Fehler: Parameter und Capture haben denselben Namen
}

Ein Lambda-Ausdruck kann eine Variable verwenden, ohne sie zu erfassen, wenn die Variable

• ist eine nicht-lokale Variable oder hat eine statische oder thread-lokale Speicherdauer (in diesem Fall kann die Variable nicht erfasst werden), oder
• ist eine Referenz, die mit einem konstanten Ausdruck initialisiert wurde.

Ein Lambda-Ausdruck kann den Wert einer Variable lesen, ohne sie zu erfassen, wenn die Variable

• hat einen const nicht-flüchtigen integralen oder Aufzählungstyp und wurde mit einem constant expression initialisiert, oder
• ist constexpr und hat keine mutable-Member.

Das aktuelle Objekt ( * this ) kann implizit erfasst werden, wenn eine Standarderfassung vorhanden ist. Wenn es implizit erfasst wird, wird es immer als Referenz erfasst, selbst wenn die Standarderfassung = ist. Die implizite Erfassung von * this bei einer Standarderfassung von = ist veraltet. (seit C++20)

Nur Lambda-Ausdrücke, die eine der folgenden Bedingungen erfüllen, dürfen eine capture-default oder capture ohne Initialisierer haben:

• Sein innerster einschließender Gültigkeitsbereich ist ein Blockgültigkeitsbereich .
• Es erscheint innerhalb eines Standard-Memberinitialisierers , und sein innerster einschließender Gültigkeitsbereich ist der entsprechende Klassengültigkeitsbereich .

Für einen solchen Lambda-Ausdruck ist der reaching scope definiert als die Menge der umschließenden Gültigkeitsbereiche bis einschließlich des innersten umschließenden Funktionsbereichs (und seiner Parameter). Dies umfasst verschachtelte Blockgültigkeitsbereiche und die Gültigkeitsbereiche umschließender Lambdas, falls dieser Lambda-Ausdruck verschachtelt ist.

Der Bezeichner in jeder Erfassung ohne Initialisierer (außer der this -Erfassung) wird mittels gewöhnlicher unqualifizierter Namenssuche im erreichbaren Gültigkeitsbereich des Lambda-Ausdrucks gesucht. Das Ergebnis der Suche muss eine Variable mit automatischer Speicherdauer sein, die im erreichbaren Gültigkeitsbereich deklariert ist , oder eine strukturierte Bindung , deren entsprechende Variable diese Anforderungen erfüllt (seit C++20) . Die Entität wird explizit erfasst .

int x = 4;
auto y = [&r = x, x = x + 1]() -> int
{
    r += 2;
    return x * x;
}(); // updates ::x to 6 and initializes y to 25.

Wenn captures einen capture-default hat und das umschließende Objekt nicht explizit erfasst (als this oder * this ), oder eine automatische Variable, die odr-verwendbar im Lambda-Rumpf ist , oder eine strukturierte Bindung , deren entsprechende Variable atomaren Speicher besitzt (seit C++20) , erfasst es die Entität implizit , wenn die Entität in einem potenziell ausgewerteten Ausdruck innerhalb eines Ausdrucks genannt wird (einschließlich wenn das implizite this - > vor einer Verwendung eines nicht-statischen Klassenmembers hinzugefügt wird).

Zum Zweck der Bestimmung impliziter Erfassungen wird typeid niemals als eine Operation betrachtet, die ihre Operanden als nicht ausgewertet behandelt.

void f(int, const int (&)[2] = {}) {}   // #1
void f(const int&, const int (&)[1]) {} // #2
struct NoncopyableLiteralType
{
    constexpr explicit NoncopyableLiteralType(int n) : n_(n) {}
    NoncopyableLiteralType(const NoncopyableLiteralType&) = delete;
    int n_;
};
void test()
{
    const int x = 17;
    auto l0 = []{ f(x); };           // OK: ruft #1 auf, erfasst x nicht
    auto g0 = [](auto a) { f(x); };  // wie oben
    auto l1 = [=]{ f(x); };          // OK: erfasst x (seit P0588R1) und ruft #1 auf
                                     // die Erfassung kann wegoptimiert werden
    auto g1 = [=](auto a) { f(x); }; // wie oben
    auto ltid = [=]{ typeid(x); };   // OK: erfasst x (seit P0588R1)
                                     // obwohl x nicht ausgewertet wird
                                     // die Erfassung kann wegoptimiert werden
    auto g2 = [=](auto a)
    {
        int selector[sizeof(a) == 1 ? 1 : 2] = {};
        f(x, selector); // OK: ist ein abhängiger Ausdruck, erfasst also x
    };
    auto g3 = [=](auto a)
    {
        typeid(a + x);  // erfasst x unabhängig davon,
                        // ob a + x ein nicht ausgewerteter Operand ist
    };
    constexpr NoncopyableLiteralType w{42};
    auto l4 = []{ return w.n_; };      // OK: w wird nicht odr-verwendet, Erfassung unnötig
    // auto l5 = [=]{ return w.n_; };  // Fehler: w muss per Kopie erfasst werden
}

Wenn der Rumpf eines Lambda-Ausdrucks odr-verwendet eine durch Kopie erfasste Entität, wird auf das Mitglied des Closure-Typs zugegriffen. Wenn die Entität nicht odr-verwendet wird, erfolgt der Zugriff auf das ursprüngliche Objekt:

void f(const int*);
void g()
{
    const int N = 10;
    [=]
    { 
        int arr[N]; // keine ODR-Verwendung: bezieht sich auf g's const int N
        f(&N); // ODR-Verwendung: verursacht, dass N erfasst wird (durch Kopie)
               // &N ist die Adresse des Member N des Closure-Objekts, nicht g's N
    }();
}

Wenn ein Lambda eine Referenz, die durch Referenz erfasst wurde, odr-verwendet, verwendet es das Objekt, auf das die ursprüngliche Referenz verweist, nicht die erfasste Referenz selbst:

#include <iostream>
auto make_function(int& x)
{
    return [&] { std::cout << x << '\n'; };
}
int main()
{
    int i = 3;
    auto f = make_function(i); // die Verwendung von x in f bindet direkt an i
    i = 5;
    f(); // OK: gibt 5 aus
}

Im Rumpf eines Lambdas mit Standard-Capture = ist der Typ jeder erfassbaren Entität so, als wäre sie erfasst worden (und somit wird oft const-Qualifizierung hinzugefügt, wenn das Lambda nicht mutable ist), selbst wenn die Entität in einem nicht ausgewerteten Operanden steht und nicht erfasst wird (z.B. in decltype ):

void f3()
{
    float x, &r = x;
    [=]
    { // x und r werden nicht erfasst (Auftreten in einem decltype-Operand ist keine ODR-Nutzung)
        decltype(x) y1;        // y1 hat den Typ float
        decltype((x)) y2 = y1; // y2 hat den Typ float const& weil dieser Lambda
                               // nicht mutable ist und x ein L-Wert ist
        decltype(r) r1 = y1;   // r1 hat den Typ float& (Transformation nicht berücksichtigt)
        decltype((r)) r2 = y2; // r2 hat den Typ float const&
    };
}

Jede Entität, die von einem Lambda erfasst wird (implizit oder explizit), wird durch den Lambda-Ausdruck odr-used (daher löst die implizite Erfassung durch ein verschachteltes Lambda die implizite Erfassung im umschließenden Lambda aus).

Alle implizit erfassten Variablen müssen innerhalb des reaching scope der Lambda-Funktion deklariert werden.

Wenn ein Lambda das umschließende Objekt erfasst (als this oder * this ), muss entweder die nächstgelegene umschließende Funktion eine nicht-statische Memberfunktion sein oder das Lambda muss sich in einem Default-Member-Initialisierer befinden:

struct s2
{
    double ohseven = .007;
    auto f() // nächstgelegene umschließende Funktion für die folgenden zwei Lambdas
    {
        return [this]      // erfasse das umschließende s2 per Referenz
        {
            return [*this] // erfasse das umschließende s2 per Kopie (C++17)
            {
                return ohseven; // OK
            }
        }();
    }
    auto g()
    {
        return [] // erfasse nichts
        { 
            return [*this] {}; // Fehler: *this nicht durch äußeren Lambda-Ausdruck erfasst
        }();
    }
};

Wenn ein Lambda-Ausdruck (oder eine Spezialisierung des Funktionsaufrufoperators eines generischen Lambda) (since C++14) ODR-verwendet * this oder eine Variable mit automatischer Speicherdauer, muss sie durch den Lambda-Ausdruck erfasst werden.

void f1(int i)
{
    int const N = 20;
    auto m1 = [=]
    {
        int const M = 30;
        auto m2 = [i]
        {
            int x[N][M]; // N und M werden nicht odr-verwendet
                         // (okay, dass sie nicht erfasst wurden)
            x[0][0] = i; // i wird explizit von m2 erfasst
                         // und implizit von m1 erfasst
        };
    };
    struct s1 // lokale Klasse innerhalb von f1()
    {
        int f;
        void work(int n) // nicht-statische Member-Funktion
        {
            int m = n * n;
            int j = 40;
            auto m3 = [this, m]
            {
                auto m4 = [&, j] // Fehler: j wird nicht von m3 erfasst
                {
                    int x = n; // Fehler: n wird implizit von m4 erfasst
                               // aber nicht von m3 erfasst
                    x += m;    // OK: m wird implizit von m4 erfasst
                               // und explizit von m3 erfasst
                    x += i;    // Fehler: i liegt außerhalb des erreichbaren Bereichs
                               // (der bei work() endet)
                    x += f;    // OK: this wird implizit von m4 erfasst
                               // und explizit von m3 erfasst
                };
            };
        }
    };
}

Klassenmitglieder können nicht explizit durch einen Capture ohne Initialisierer erfasst werden (wie oben erwähnt, sind nur Variablen in der capture-list erlaubt):

class S
{
    int x = 0;
    void f()
    {
        int i = 0;
    //  auto l1 = [i, x] { use(i, x); };      // Fehler: x ist keine Variable
        auto l2 = [i, x = x] { use(i, x); };  // OK, Kopiererfassung
        i = 1; x = 1; l2(); // ruft use(0,0) auf
        auto l3 = [i, &x = x] { use(i, x); }; // OK, Referenzerfassung
        i = 2; x = 2; l3(); // ruft use(1,2) auf
    }
};

Wenn ein Lambda ein Mitglied durch implizite Kopiererfassung erfasst, wird keine Kopie dieser Mitgliedsvariable erstellt: Die Verwendung einer Mitgliedsvariable m wird als Ausdruck ( * this ) . m behandelt, und * this wird immer implizit per Referenz erfasst:

class S
{
    int x = 0;
    void f()
    {
        int i = 0;
        auto l1 = [=] { use(i, x); }; // erfasst eine Kopie von i und
                                      // eine Kopie des this-Zeigers
        i = 1; x = 1; l1();           // ruft use(0, 1) auf, als ob
                                      // i per Kopie und x per Referenz
        auto l2 = [i, this] { use(i, x); }; // wie oben, explizit gemacht
        i = 2; x = 2; l2();           // ruft use(1, 2) auf, als ob
                                      // i per Kopie und x per Referenz
        auto l3 = [&] { use(i, x); }; // erfasst i per Referenz und
                                      // eine Kopie des this-Zeigers
        i = 3; x = 2; l3();           // ruft use(3, 2) auf, als ob
                                      // i und x beide per Referenz
        auto l4 = [i, *this] { use(i, x); }; // erstellt eine Kopie von *this,
                                             // einschließlich einer Kopie von x
        i = 4; x = 4; l4();           // ruft use(3, 2) auf, als ob
                                      // i und x beide per Kopie
    }
};

Wenn ein Lambda-Ausdruck in einem Standardargument erscheint, kann er nichts explizit oder implizit erfassen , es sei denn, alle Erfassungen haben Initialisierer, die den Einschränkungen eines Ausdrucks entsprechen, der in einem Standardargument erscheint (seit C++14) :

void f2()
{
    int i = 1;
    void g1( int = [i] { return i; }() ); // Fehler: erfasst etwas
    void g2( int = [i] { return 0; }() ); // Fehler: erfasst etwas
    void g3( int = [=] { return i; }() ); // Fehler: erfasst etwas
    void g4( int = [=] { return 0; }() );       // OK: erfasst nichts
    void g5( int = [] { return sizeof i; }() ); // OK: erfasst nichts
    // C++14
    void g6( int = [x = 1] { return x; }() ); // OK: 1 kann in einem
                                              //     Standardargument erscheinen
    void g7( int = [x = i] { return x; }() ); // Fehler: i kann nicht in einem
                                              //        Standardargument erscheinen
}

Mitglieder von anonymen Unions können nicht erfasst werden. Bit-Felder können nur durch Kopie erfasst werden.

Wenn eine verschachtelte Lambda-Funktion m2 etwas erfasst, das auch von der unmittelbar umschließenden Lambda-Funktion m1 erfasst wird, dann wird die Erfassung von m2 wie folgt transformiert:

• wenn die umschließende Lambda-Funktion m1 durch Kopie erfasst, m2 erfasst das nicht-statische Mitglied des Closure-Typs von m1 , nicht die ursprüngliche Variable oder * this ; wenn m1 nicht mutable ist, wird das nicht-statische Datenelement als const-qualifiziert betrachtet.
• wenn die umschließende Lambda-Funktion m1 durch Referenz erfasst, m2 erfasst die ursprüngliche Variable oder * this .

#include <iostream>
int main()
{
    int a = 1, b = 1, c = 1;
    auto m1 = [a, &b, &c]() mutable
    {
        auto m2 = [a, b, &c]() mutable
        {
            std::cout << a << b << c << '\n';
            a = 4; b = 4; c = 4;
        };
        a = 3; b = 3; c = 3;
        m2();
    };
    a = 2; b = 2; c = 2;
    m1();                             // ruft m2() auf und gibt 123 aus
    std::cout << a << b << c << '\n'; // gibt 234 aus
}

struct C 
{
    template<typename T>
    C(T);
};
void func(int i) 
{
    int x = [=](this auto&&) { return i; }();  // OK
    int y = [=](this C) { return i; }();       // error
    int z = [](this C) { return 42; }();       // OK
    auto lambda = [n = 42] (this auto self) { return n; };
    using Closure = decltype(lambda);
    struct D : private Closure {
        D(Closure l) : Closure(l) {}
        using Closure::operator();
        friend Closure;
    };
    D{lambda}(); // error
}

Hinweise

Die Regel für implizite Lambda-Erfassung wurde durch den Defektbericht P0588R1 leicht geändert. Stand 2023-10 haben einige wichtige Implementierungen diesen DR noch nicht vollständig umgesetzt, weshalb in einigen Fällen weiterhin die alte Regel, die ODR-Verwendung erkennt, angewendet wird.

Beispiel

#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> c{1, 2, 3, 4, 5, 6, 7};
    int x = 5;
    c.erase(std::remove_if(c.begin(), c.end(), [x](int n) { return n < x; }), c.end());
    std::cout << "c: ";
    std::for_each(c.begin(), c.end(), [](int i) { std::cout << i << ' '; });
    std::cout << '\n';
    // der Typ eines Closures kann nicht benannt werden, kann jedoch mit auto abgeleitet werden
    // seit C++14 kann Lambda eigene Standardargumente besitzen
    auto func1 = [](int i = 6) { return i + 4; };
    std::cout << "func1: " << func1() << '\n';
    // wie alle aufrufbaren Objekte können Closures in std::function erfasst werden
    // (dies könnte unnötigen Overhead verursachen)
    std::function<int(int)> func2 = [](int i) { return i + 4; };
    std::cout << "func2: " << func2(6) << '\n';
    constexpr int fib_max {8};
    std::cout << "Emuliere `rekursive Lambda`-Aufrufe:\nFibonacci-Zahlen: ";
    auto nth_fibonacci = [](int n)
    {
        std::function<int(int, int, int)> fib = [&](int n, int a, int b)
        {
            return n ? fib(n - 1, a + b, a) : b;
        };
        return fib(n, 0, 1);
    };
    for (int i{1}; i <= fib_max; ++i)
        std::cout << nth_fibonacci(i) << (i < fib_max ? ", " : "\n");
    std::cout << "Alternativer Ansatz für Lambda-Rekursion:\nFibonacci-Zahlen: ";
    auto nth_fibonacci2 = [](auto self, int n, int a = 0, int b = 1) -> int
    {
        return n ? self(self, n - 1, a + b, a) : b;
    };
    for (int i{1}; i <= fib_max; ++i)
        std::cout << nth_fibonacci2(nth_fibonacci2, i) << (i < fib_max ? ", " : "\n");
#ifdef __cpp_explicit_this_parameter
    std::cout << "C++23 Ansatz zur Lambda-Rekursion:\n";
    auto nth_fibonacci3 = [](this auto self, int n, int a = 0, int b = 1) -> int
    {
         return n ? self(n - 1, a + b, a) : b;
    };
    for (int i{1}; i <= fib_max; ++i)
        std::cout << nth_fibonacci3(i) << (i < fib_max ? ", " : "\n");
#endif
}

c: 5 6 7
func1: 10
func2: 10
Emuliere `rekursive Lambda`-Aufrufe:
Fibonacci-Zahlen: 0, 1, 1, 2, 3, 5, 8, 13
Alternativer Ansatz für Lambda-Rekursion:
Fibonacci-Zahlen: 0, 1, 1, 2, 3, 5, 8, 13

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch

Externe Links