C++
parola chiave mutevole

modificatore del membro della classe non statico

mutable modificatore mutable in questo contesto è usato per indicare che un campo dati di un oggetto const può essere modificato senza influenzare lo stato visibile esternamente dell'oggetto.

Se stai pensando di memorizzare nella cache un risultato di costosi calcoli, dovresti probabilmente usare questa parola chiave.

Se si dispone di un campo di dati di blocco (ad esempio, std::unique_lock ) che è bloccato e sbloccato all'interno di un metodo const, questa parola chiave è anche ciò che è possibile utilizzare.

Non si dovrebbe usare questa parola chiave per interrompere la costanza logica di un oggetto.

Esempio con la memorizzazione nella cache:

class pi_calculator {
 public:
     double get_pi() const {
         if (pi_calculated) {
             return pi;
         } else {
             double new_pi = 0;
             for (int i = 0; i < 1000000000; ++i) {
                 // some calculation to refine new_pi
             }
             // note: if pi and pi_calculated were not mutable, we would get an error from a compiler
             // because in a const method we can not change a non-mutable field
             pi = new_pi;
             pi_calculated = true;
             return pi;
         }
     }
 private:
     mutable bool pi_calculated = false;
     mutable double pi = 0;
};

mutande lambda

Per impostazione predefinita, l' operator() implicito operator() di un lambda è const . Ciò non consente di eseguire operazioni non const sul lambda. Per consentire la modifica dei membri, una lambda può essere contrassegnata come mutable , il che rende l' operator() implicito operator() non const :

int a = 0;

auto bad_counter = [a] {
    return a++;   // error: operator() is const
                  // cannot modify members
};

auto good_counter = [a]() mutable {
    return a++;  // OK
}

good_counter(); // 0
good_counter(); // 1
good_counter(); // 2