C++
muterbara nyckelord

icke-statisk klassmedlem modifierare

mutable modifieraren i detta sammanhang används för att indikera att ett datafält för ett const-objekt kan modifieras utan att det påverkar objektets externt synliga tillstånd.

Om du funderar på att cache ett resultat av dyra beräkningar, bör du förmodligen använda detta nyckelord.

Om du har ett lås (till exempel std::unique_lock ) std::unique_lock som är låst och låst upp i en const-metod är detta nyckelord också det du kan använda.

Du bör inte använda det här nyckelordet för att bryta logiskt konstnitet hos ett objekt.

Exempel med caching:

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

muterbara lambdas

Som standard är den implicita operator() för en lambda const . Detta tillåter inte att utföra icke- const operationer på lambda. För att möjliggöra modifiering av medlemmar kan en lambda vara markerad mutable , vilket gör den implicita operator() icke- 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