C++
veränderbares Schlüsselwort

Nicht statischer Klassenmitgliedsmodifizierer

mutable Modifizierer wird in diesem Zusammenhang verwendet, um anzuzeigen, dass ein Datenfeld eines const-Objekts geändert werden kann, ohne den von außen sichtbaren Zustand des Objekts zu beeinflussen.

Wenn Sie über das Zwischenspeichern eines Ergebnisses einer kostspieligen Berechnung nachdenken, sollten Sie dieses Schlüsselwort wahrscheinlich verwenden.

Wenn Sie ein Sperrdatenfeld (z. B. std::unique_lock ) haben, das in einer const-Methode gesperrt und nicht gesperrt ist, können Sie dieses Schlüsselwort auch verwenden.

Sie sollten dieses Schlüsselwort nicht verwenden, um die logische Konstanz eines Objekts zu unterbrechen.

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

veränderliche Lambdas

Der implizite operator() eines Lambda ist standardmäßig const . Diese verbietet notleidender const auf der Lambda - Operationen. Um modifizierende Elemente zuzulassen, kann ein Lambda als mutable markiert werden, wodurch der implizite operator() nicht- 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