Warum wird C++11 lambda-Ausdruck benötigen "veränderlich" keyword " capture-by-Wert, per default?

Dein code ist fast äquivalent zu dieser:

#include <iostream>

class unnamed1
{
    int& n;
public:
    unnamed1(int& N) : n(N) {}

    /* OK. Your this is const but you don't modify the "n" reference,
    but the value pointed by it. You wouldn't be able to modify a reference
    anyway even if your operator() was mutable. When you assign a reference
    it will always point to the same var.
    */
    void operator()() const {n = 10;}
};

class unnamed2
{
    int n;
public:
    unnamed2(int N) : n(N) {}

    /* OK. Your this pointer is not const (since your operator() is "mutable" instead of const).
    So you can modify the "n" member. */
    void operator()() {n = 20;}
};

class unnamed3
{
    int n;
public:
    unnamed3(int N) : n(N) {}

    /* BAD. Your this is const so you can't modify the "n" member. */
    void operator()() const {n = 10;}
};

int main()
{
    int n;
    unnamed1 u1(n); u1();    //OK
    unnamed2 u2(n); u2();    //OK
    //unnamed3 u3(n); u3();  //Error
    std::cout << n << "\n";  //"10"
}

So könnte man denken, dass Lambda-Ausdrücke erzeugen Sie eine Klasse mit operator (), der standardmäßig const, es sei denn, Sie sagen, es ist veränderlich.

Können Sie auch alle Variablen erfasst innen [] (explizit oder implizit) als Mitglieder dieser Klasse: Kopien der Objekte, die für [=] oder Verweise auf die Objekte, die für [&]. Sie werden initialisiert, wenn Sie erklären Ihren lambda, als ob es eine versteckte Konstruktor.

InformationsquelleAutor Daniel Muñoz

FWIW, Herb Sutter, einem bekannten Mitglied der C++ - Standardisierung-Komitees, liefert eine andere Antwort auf diese Frage in Lambda Korrektheit und Usability-Probleme:

Betrachten Sie diese Strohmann-Beispiel, wo der Programmierer erfasst eine lokale variable, indem Sie
Wert und versucht, ändern Sie die
erfassten Wert (das ist eine member-variable des lambda-Objekt):

int val = 0;
auto x = [=](item e)            //look ma, [=] means explicit copy
            { use(e,++val); };  //error: count is const, need ‘mutable’
auto y = [val](item e)          //darnit, I really can’t get more explicit
            { use(e,++val); };  //same error: count is const, need ‘mutable’

Dieses feature wird Hinzugefügt worden aus Sorge, dass der Benutzer
könnte nicht erkennen, er bekam eine Kopie, und insbesondere, dass seit lambdas
sind kopierbar er verändert werden könnte eine andere lambda kopieren.

Seinem Papier über, warum dies sollte geändert werden in C++14. Es ist kurz, gut geschrieben, lesenswert, wenn man wissen will "was auf [Ausschussmitglied] Geist" mit Bezug auf diese Besonderheit.

InformationsquelleAutor akim

Müssen Sie denken, was ist der Verschluss Typ Ihrer Lambda-Funktion. Jedes mal, wenn Sie deklarieren ein Lambda-Ausdruck, der compiler erstellt eine Schließung geben, die nichts weniger als eine Unbenannte Klasse Erklärung mit Parametern (Umgebung, wo die Lambda-Ausdruck, wo erklärt) und der Funktion Anruf ::operator() umgesetzt. Wenn Sie erfassen einer Variablen, die mit copy-by-value, erstellt der compiler einen neuen const Attribut in den Verschluss geben, so können Sie es nicht ändern innerhalb der Lambda-Ausdruck, weil es eine "nur Lesen"-Attribut, das ist der Grund, warum Sie nennen es ein "Schließung", weil Sie in irgendeiner Weise, die Sie schließen Ihren Lambda-Ausdruck kopieren Sie die Variablen aus den oberen Bereich in die Lambda Umfang. Wenn Sie das Schlüsselwort verwenden mutable die erfasste Person wurde ein non-const Attribut des closure-Typs. Dies ist, was bewirkt, dass die änderungen in das mutable-Variablen erfasst, die von Wert, nicht weitergegeben oberen Rahmen, aber halten Sie innerhalb der stateful Lambda.
Immer versuchen Sie sich vorzustellen, die daraus resultierende Schließung Typ des Lambda-Ausdrucks, das hat mir sehr geholfen, und ich hoffe, es kann dir auch helfen.

InformationsquelleAutor Tarantula

Gibt es jetzt einen Vorschlag zu lindern die Notwendigkeit mutable im lambda-Deklarationen: n3424

InformationsquelleAutor usta

Verlängern Hund die Antwort, lambda-Funktionen verwendet werden sollen,Reine Funktionen. Das bedeutet, dass jeder Aufruf einen eindeutigen input-set gibt immer die gleiche Ausgabe. Wir definieren Eingang als die Menge aller Argumente sowie alle erfassten Variablen, wenn der lambda-Ausdruck genannt.

In reinen Funktionen, Ausgang hängt ab von Eingabe und nicht auf einem internen Zustand. Daher kann der lambda-Funktion, wenn rein, nicht brauchen, um Ihren Zustand ändern und ist daher unveränderlich.

Wenn ein lambda-Ausdruck erfasst, die durch Verweis, schriftlich auf captured Variablen ist eine Belastung, die auf das Konzept der reinen Funktion, da alle eine Reine Funktion tun sollten, ist die Rückkehr eine Ausgabe, wenn die lambda nicht sicher mutieren, weil das schreiben geschieht auf externe Variablen. Auch in diesem Fall eine korrekte Verwendung impliziert, dass, wenn der lambda-Ausdruck aufgerufen, mit dem gleichen Eingang wieder, der output wird der gleiche sein jedes mal, trotz dieser Nebenwirkungen auf, die durch-ref-Variablen. Solche Nebenwirkungen sind nur Möglichkeiten, um wieder einige weitere Eingabe (z.B. ein update-Zähler) und könnte umformuliert werden in eine Reine Funktion, zum Beispiel bei der Rückkehr ein Tupel anstatt einen einzelnen Wert.

InformationsquelleAutor Attersson