C++
palabra clave mutable

modificador de miembro de clase no estático

mutable modificador mutable en este contexto se usa para indicar que un campo de datos de un objeto const puede modificarse sin afectar el estado visible externamente del objeto.

Si está pensando en almacenar en caché el resultado de un cálculo costoso, probablemente debería usar esta palabra clave.

Si tiene un campo de datos de bloqueo (por ejemplo, std::unique_lock ) que está bloqueado y desbloqueado dentro de un método const, esta palabra clave también es lo que podría usar.

No debe usar esta palabra clave para romper la constancia lógica de un objeto.

Ejemplo con caché:

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;
};

lambdas mutables

Por defecto, el operator() implícito operator() de un lambda es const . Esto no permite realizar operaciones no const en la lambda. Para permitir la modificación de miembros, un lambda puede marcarse como mutable , lo que hace que el operator() implícito operator() no sea 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