C++ - Lambdas: Unterschied zwischen "veränderlich" und capture-by-reference

In C++ können Sie erklären, Lambda-Ausdrücke zum Beispiel so:

int x = 5;
auto a = [=]() mutable { ++x; std::cout << x << '\n'; };
auto b = [&]()         { ++x; std::cout << x << '\n'; };

Beide lassen mich ändern x, was ist also der Unterschied?

InformationsquelleAutor Sebastian Mach | 2013-06-05

c++c++11 lambda

85

Was passiert

Den ersten nur ändern, eine eigene Kopie von x und verlassen die Außenseite x unverändert.
Mit dem zweiten ändern Sie die außerhalb x.

Fügen Sie eine print-Anweisung ausprobiert:
```
a();
std::cout << x << "----\n";
b();
std::cout << x << '\n';
```
Dies ist das erwartete zu drucken:
```
6
5
----
6
6
```
Warum

Kann es helfen zu beachten, dass die lambda

[...] Ausdrücke bieten einen prägnanten Weg, um erstellen einfache Funktion Objekte

^{(siehe [expr.prim.lambda] der Standard)}

Haben Sie

[...] einem öffentlichen inline-function-call-operator [...]

erklärt als const member-Funktion, aber nur

[ ... ], wenn und nur wenn die lambda-Ausdrucks parameter-Erklärung-Klausel ist nicht gefolgt von mutable

Können Sie denken, als wenn
```
    int x = 5;
    auto a = [=]() mutable { ++x; std::cout << x << '\n'; };

==>

    int x = 5;

    class __lambda_a {
        int x;
    public:
        __lambda_a () : x($lookup-one-outer$::x) {}
        inline void operator() { ++x; std::cout << x << '\n'; }     
    } a;
```
und
```
    auto b = [&]()         { ++x; std::cout << x << '\n'; };

==>

    int x = 5;

    class __lambda_b {
        int &x;
    public:
        __lambda_b() : x($lookup-one-outer$::x) {}
        inline void operator() const { ++x; std::cout << x << '\n'; }         
        //                    ^^^^^
    } b;
```
Q: Aber wenn es ein const Funktion, warum kann ich immer noch ändern x?

A: Sie ändern nur die die außerhalb x. Die lambda eigenen x ist ein Verweis, und den Betrieb ++x nicht ändern die Referenz, aber der angegebene Wert.

Dies funktioniert, weil in C++, der constness des einen Zeiger/Referenz ändert nicht die constness der pointee/referencee gesehen durch ihn.
- Gut und gründlich. Aber ich denke, Sie haben a einige Orte, die Sie gemeint b. Und Ihre Objekte von anonymen Klasse Typ nicht Initialisierungen. Vielleicht möchten Sie erklären, wir sind pretending lambda_a() ist ein Konstruktor, obwohl die Klasse keinen Namen hat.
- Danke für die Vorschläge 🙂 ich habe zu reservierten Namen.
- Könnten Sie erklären, ein bisschen mehr über die constness? Ich habe nicht ein klares Bild gibt. Ich denke, die erklären, was passieren würde, wenn die 'const' nicht anwesend war, würde es einfach machen.
- Im letzten Beispiel, die const macht eigentlich keinen Unterschied. Sie immer mutieren die referencee durch einen Verweis. Aber um ein anderes Beispiel anzuführen: int main () { int x; auto a = [=]() { ++x; }; }. g++ wird eine Fehlermeldung geben, weil die [=] bedeutet, dass die generierte Funktion Objekt bekommt seine eigene member-variable x, aber der Mangel an mutable bedeutet, dass ein const member-function-call-operator erzeugt, daher die x ist nicht übertragbar.
- Ausgezeichnet! +1 vor allem für den obigen Kommentar und der constness des einen Zeiger/Referenz ändert nicht die constness der pointee/referencee gesehen durch ihn. Das hinzufügen diesem Fall auto c = [=]() { ++x; }; oben geben würde, ist mehr Klarheit darüber, warum mutable, und dort durch const, macht einen Unterschied.
- Die Frage ist, warum die Konvention genommen wird, in umgekehrter verglichen mit sonst alles in C++. mutable Qualifikation sollte standardmäßig const Spezifikation sollten explizit genannt werden.
- Vielleicht, weil es allzu leicht versehentlich ändern Sie die Erfassung von Kopie, z.B. int sum = 0; std::for_each(vec.cbegin(), vec.cend(), [sum](int x) { sum += x;}).
InformationsquelleAutor Sebastian Mach

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Was passiert

Warum