C++
mot-clé mutable

modificateur de membre de classe non statique

mutable modificateur mutable dans ce contexte est utilisé pour indiquer qu'un champ de données d'un objet const peut être modifié sans affecter l'état visible de l'objet de manière externe.

Si vous envisagez de mettre en cache un résultat de calcul coûteux, vous devriez probablement utiliser ce mot-clé.

Si vous avez un champ de données de verrouillage (par exemple, std::unique_lock ) qui est verrouillé et déverrouillé dans une méthode const, ce mot clé est également ce que vous pourriez utiliser.

Vous ne devez pas utiliser ce mot-clé pour casser la constance logique d'un objet.

Exemple avec mise en 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;
};

lambda mutable

Par défaut, l' operator() implicite operator() d'un lambda est const . Cela interdit d'effectuer des opérations non const sur le lambda. Pour permettre la modification des membres, un lambda peut être marqué comme mutable , ce qui rend l' operator() implicite 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