Perché lambda di C ++ 11 richiede la parola chiave "mutable" per acquisizione per valore, per impostazione predefinita?

Breve esempio:

#include <iostream>

int main()
{
    int n;
    [&](){n = 10;}();             // OK
    [=]() mutable {n = 20;}();    // OK
    // [=](){n = 10;}();          // Error: a by-value capture cannot be modified in a non-mutable lambda
    std::cout << n << "\n";       // "10"
}

La domanda: perché abbiamo bisogno della mutableparola chiave? È abbastanza diverso dal parametro tradizionale che passa alle funzioni con nome. Qual è la logica alla base?

Avevo l'impressione che l'intero punto di acquisizione per valore sia consentire all'utente di modificare il temporaneo, altrimenti sto quasi sempre meglio usando l'acquisizione per riferimento, non è vero?

Qualche illuminazione?

(Sto usando MSVC2010 a proposito. AFAIK questo dovrebbe essere standard)

Richiede mutableperché, per impostazione predefinita, un oggetto funzione dovrebbe produrre lo stesso risultato ogni volta che viene chiamato. Questa è la differenza tra una funzione orientata agli oggetti e una funzione che utilizza una variabile globale, in modo efficace.

Il tuo codice è quasi equivalente a questo:

#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"
}

Quindi potresti pensare a lambdas come a generare una classe con operator () che per impostazione predefinita è const a meno che tu non dica che è mutabile.

Puoi anche pensare a tutte le variabili catturate all'interno di [] (esplicitamente o implicitamente) come membri di quella classe: copie degli oggetti per [=] o riferimenti agli oggetti per [&]. Vengono inizializzati quando dichiari il tuo lambda come se ci fosse un costruttore nascosto.

Avevo l'impressione che l'intero punto di acquisizione per valore sia consentire all'utente di modificare il temporaneo, altrimenti sto quasi sempre meglio usando l'acquisizione per riferimento, non è vero?

La domanda è: è "quasi"? Un caso d'uso frequente sembra essere quello di restituire o superare lambdas:

void registerCallback(std::function<void()> f) { /* ... */ }

void doSomething() {
  std::string name = receiveName();
  registerCallback([name]{ /* do something with name */ });
}

Penso che mutablenon sia un caso di "quasi". Considero "acquisizione per valore" come "permettimi di usare il suo valore dopo che l'entità catturata muore" piuttosto che "permettimi di cambiarne una copia". Ma forse questo può essere discusso.

FWIW, Herb Sutter, noto membro del comitato di standardizzazione C ++, fornisce una risposta diversa a quella domanda in Problemi di correttezza e usabilità di Lambda :

Considera questo esempio di paglia, in cui il programmatore acquisisce una variabile locale in base al valore e tenta di modificare il valore acquisito (che è una variabile membro dell'oggetto lambda):

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’

Questa funzione sembra essere stata aggiunta per la preoccupazione che l'utente potrebbe non rendersi conto di averne una copia, e in particolare che, poiché i lambda sono copiabili, potrebbe cambiare una copia di lambda diversa.

Il suo articolo spiega perché questo dovrebbe essere cambiato in C ++ 14. È breve, ben scritto, che vale la pena leggere se si desidera sapere "cosa c'è nella mente di [membri del comitato]" riguardo a questa particolare caratteristica.

Devi pensare qual è il tipo di chiusura della tua funzione Lambda. Ogni volta che dichiari un'espressione Lambda, il compilatore crea un tipo di chiusura, che non è altro che una dichiarazione di classe senza nome con attributi ( ambiente in cui è stata dichiarata l'espressione Lambda) e la chiamata di funzione ::operator()implementata. Quando acquisisci una variabile usando il valore di copia per valore , il compilatore creerà un nuovo constattributo nel tipo di chiusura, quindi non puoi cambiarlo all'interno dell'espressione Lambda perché è un attributo di "sola lettura", ecco perché chiamalo " chiusura ", perché in qualche modo stai chiudendo la tua espressione Lambda copiando le variabili dall'ambito superiore all'ambito Lambda.mutable, l'entità acquisita diventerà un non-constattributo del tipo di chiusura. Questo è ciò che fa sì che le modifiche apportate alla variabile mutabile catturate dal valore non vengano propagate all'ambito superiore, ma rimangano all'interno della lambda con stato. Cerca sempre di immaginare il tipo di chiusura risultante della tua espressione Lambda, che mi ha aiutato molto e spero che possa aiutarti anche tu.

Vedi questa bozza , in 5.1.2 [expr.prim.lambda], sottoclauso 5:

Il tipo di chiusura per un'espressione lambda ha un operatore di chiamata di funzione inline pubblica (13.5.4) i cui parametri e tipo di ritorno sono descritti rispettivamente dalla clausola di dichiarazione dei parametri dell'espressione lambda e dal tipo di trailingreturn. Questo operatore di chiamata di funzione è dichiarato const (9.3.1) se e solo se la clausola di dichiarazione dei parametri della lambdaexpression non è seguita da mutable.

Modifica sul commento di litb: Forse hanno pensato alla cattura per valore in modo che le modifiche esterne alle variabili non si riflettano all'interno della lambda? I riferimenti funzionano in entrambi i modi, quindi questa è la mia spiegazione. Non so se va bene comunque.

Modifica sul commento di kizzx2: il maggior numero di volte in cui una lambda deve essere utilizzata è una funzione per gli algoritmi. L'impostazione predefinita constconsente di utilizzarlo in un ambiente costante, proprio come le normali constfunzioni qualificate possono essere utilizzate lì, ma non constquelle non qualificate. Forse hanno solo pensato di renderlo più intuitivo per quei casi, che sanno cosa succede nella loro mente. :)

Avevo l'impressione che l'intero punto di acquisizione per valore sia consentire all'utente di modificare il temporaneo, altrimenti sto quasi sempre meglio usando l'acquisizione per riferimento, non è vero?

nnon è un temporaneo. n è un membro dell'oggetto funzione lambda creato con l'espressione lambda. L'aspettativa di default è che chiamare il tuo lambda non modifichi il suo stato, quindi è costante per impedirti di modificare accidentalmente n.

Devi capire cosa significa catturare! sta catturando non passare argomenti! diamo un'occhiata ad alcuni esempi di codice:

int main()
{
    using namespace std;
    int x = 5;
    int y;
    auto lamb = [x]() {return x + 5; };

    y= lamb();
    cout << y<<","<< x << endl; //outputs 10,5
    x = 20;
    y = lamb();
    cout << y << "," << x << endl; //output 10,20

}

Come puoi vedere anche se xè stato modificato in 20lambda sta ancora ritornando 10 ( xè ancora 5all'interno della lambda) Cambiare xall'interno della lambda significa cambiare la stessa lambda ad ogni chiamata (la lambda sta mutando ad ogni chiamata). Per imporre la correttezza lo standard ha introdotto la mutableparola chiave. Specificando un lambda come mutabile stai dicendo che ogni chiamata al lambda potrebbe causare un cambiamento nel lambda stesso. Vediamo un altro esempio:

int main()
{
    using namespace std;
    int x = 5;
    int y;
    auto lamb = [x]() mutable {return x++ + 5; };

    y= lamb();
    cout << y<<","<< x << endl; //outputs 10,5
    x = 20;
    y = lamb();
    cout << y << "," << x << endl; //outputs 11,20

}

L'esempio sopra mostra che rendendo mutevole la lambda, cambiare xall'interno della lambda "muta" la lambda ad ogni chiamata con un nuovo valore xche non ha nulla a che fare con il valore reale di xnella funzione principale

Esiste ora una proposta per alleviare la necessità di mutabledichiarazioni lambda: n3424

Per estendere la risposta di Puppy, le funzioni lambda sono intese come funzioni pure . Ciò significa che ogni chiamata a cui viene assegnato un set di input univoco restituisce sempre lo stesso output. Definiamo l' input come l'insieme di tutti gli argomenti più tutte le variabili acquisite quando viene chiamato lambda.

Nelle funzioni pure l'output dipende esclusivamente dall'input e non da un certo stato interno. Pertanto qualsiasi funzione lambda, se pura, non ha bisogno di cambiare il suo stato ed è quindi immutabile.

Quando una lambda cattura per riferimento, scrivere sulle variabili catturate è una tensione sul concetto di funzione pura, perché tutto ciò che una funzione pura dovrebbe fare è restituire un output, sebbene la lambda non muti certamente perché la scrittura avviene su variabili esterne. Anche in questo caso un uso corretto implica che se si chiama nuovamente lambda con lo stesso input, l'output sarà lo stesso ogni volta, nonostante questi effetti collaterali sulle variabili by-ref. Tali effetti collaterali sono solo modi per restituire alcuni input aggiuntivi (ad esempio aggiornare un contatore) e potrebbero essere riformulati in una funzione pura, ad esempio restituendo una tupla anziché un singolo valore.