Hat das Schlüsselwort 'mutable' einen anderen Zweck als das Ändern der Variablen durch eine const-Funktion?

Vor einiger Zeit bin ich auf Code gestoßen, der eine Mitgliedsvariable einer Klasse mit dem mutableSchlüsselwort markiert . Soweit ich sehen kann, können Sie damit einfach eine Variable in einer constMethode ändern :

class Foo  
{  
private:  
    mutable bool done_;  
public:  
    void doSomething() const { ...; done_ = true; }  
};

Ist dies die einzige Verwendung dieses Schlüsselworts oder steckt mehr dahinter, als man denkt? Ich habe diese Technik seitdem in einer Klasse verwendet und eine boost::mutexals veränderlich markiert, damit constFunktionen sie aus Gründen der Thread-Sicherheit sperren können, aber um ehrlich zu sein, fühlt es sich wie ein Hack an.

Es ermöglicht die Unterscheidung von bitweiser Konstante und logischer Konstante. Logische Konstante ist, wenn sich ein Objekt nicht auf eine Weise ändert, die über die öffentliche Schnittstelle sichtbar ist, wie in Ihrem Sperrbeispiel. Ein anderes Beispiel wäre eine Klasse, die beim ersten Anfordern einen Wert berechnet und das Ergebnis zwischenspeichert.

Da c ++ 11 mutableauf einem Lambda verwendet werden kann, um anzuzeigen, dass durch Wert erfasste Dinge modifizierbar sind (sie sind nicht standardmäßig):

int x = 0;
auto f1 = [=]() mutable {x = 42;};  // OK
auto f2 = [=]()         {x = 42;};  // Error: a by-value capture cannot be modified in a non-mutable lambda

Das mutableSchlüsselwort ist eine Möglichkeit, den constSchleier zu durchbohren, den Sie über Ihre Objekte legen. Wenn Sie eine konstante Referenz oder Zeiger auf ein Objekt haben, können Sie dieses Objekt nicht in irgendeiner Weise ändern , außer , wann und wie es markiert ist mutable.

Mit Ihrer constReferenz oder Ihrem Zeiger sind Sie beschränkt auf:

• Lesezugriff nur für sichtbare Datenelemente
• Berechtigung, nur Methoden aufzurufen, die als gekennzeichnet sind const.

Mit der mutableAusnahme können Sie jetzt markierte Datenelemente schreiben oder festlegen mutable. Das ist der einzige äußerlich sichtbare Unterschied.

Intern können die constfür Sie sichtbaren Methoden auch in markierte Datenelemente schreiben mutable. Im Wesentlichen wird der konstante Schleier umfassend durchbohrt. Es liegt ganz beim API-Designer, sicherzustellen, dass mutabledas constKonzept nicht zerstört wird und nur in nützlichen Sonderfällen verwendet wird. Das mutableSchlüsselwort hilft, da es Datenelemente, die diesen Sonderfällen unterliegen, eindeutig kennzeichnet.

In der Praxis können Sie constIhre Codebasis zwanghaft verwenden (Sie möchten Ihre Codebasis im Wesentlichen mit der const"Krankheit" "infizieren "). In dieser Welt sind Zeiger und Referenzenconst mit sehr wenigen Ausnahmen , die Code liefern, der leichter zu verstehen und zu verstehen ist. Für einen interessanten Exkurs schauen Sie nach "referentielle Transparenz".

Ohne das mutableSchlüsselwort werden Sie möglicherweise gezwungen sein, const_castdie verschiedenen nützlichen Sonderfälle zu behandeln, die es zulässt (Caching, Ref-Counting, Debug-Daten usw.). Leider const_castist es wesentlich destruktiver als mutableweil es den API- Client zwingt , den constSchutz der von ihm verwendeten Objekte zu zerstören . Darüber hinaus führt dies zu einer weit verbreiteten constZerstörung: const_castWenn Sie einen konstanten Zeiger oder eine Referenz verwenden, können Sie uneingeschränkt schreiben und Methoden aufrufen, um auf sichtbare Elemente zuzugreifen. Im Gegensatz dazu mutablemuss der API-Designer die constAusnahmen genau steuern. In der Regel sind diese Ausnahmen in constMethoden verborgen , die mit privaten Daten arbeiten.

(Hinweis: Ich beziehe mich einige Male auf die Sichtbarkeit von Daten und Methoden . Ich spreche von Mitgliedern, die als öffentlich oder privat oder geschützt gekennzeichnet sind. Dies ist eine völlig andere Art des hier diskutierten Objektschutzes .)

Ihre Verwendung mit boost :: mutex ist genau das, wofür dieses Schlüsselwort bestimmt ist. Eine andere Verwendung ist das interne Zwischenspeichern von Ergebnissen, um den Zugriff zu beschleunigen.

Grundsätzlich gilt "veränderlich" für alle Klassenattribute, die den extern sichtbaren Zustand des Objekts nicht beeinflussen.

In dem Beispielcode in Ihrer Frage ist veränderlich möglicherweise unangemessen, wenn der Wert von done_ den externen Status beeinflusst. Dies hängt davon ab, was in ... enthalten ist. Teil.

Mutable dient zum Markieren eines bestimmten Attributs als innerhalb von constMethoden veränderbar. Das ist der einzige Zweck. Überlegen Sie sorgfältig, bevor Sie es verwenden, da Ihr Code wahrscheinlich sauberer und lesbarer ist, wenn Sie das Design ändern, anstatt es zu verwenden mutable.

http://www.highprogrammer.com/alan/rants/mutable.html

Also, wenn der obige Wahnsinn nicht das ist, wofür veränderlich ist, wofür ist er dann? Hier ist der subtile Fall: Veränderbar ist für den Fall, dass ein Objekt logisch konstant ist, sich aber in der Praxis ändern muss. Diese Fälle sind selten, aber es gibt sie.

Beispiele, die der Autor angibt, sind Caching- und temporäre Debugging-Variablen.

Dies ist nützlich in Situationen, in denen Sie den internen Status ausgeblendet haben, z. B. in einem Cache. Zum Beispiel:

Klasse HashTable
{
...
Öffentlichkeit:
    String-Suche (String-Schlüssel) const
    {
        if (key == lastKey)
            return lastValue;

        Zeichenfolgenwert = lookupInternal (Schlüssel);

        lastKey = key;
        lastValue = value;

        Rückgabewert;
    }}

Privat:
    veränderbare Zeichenfolge lastKey, lastValue;
};

Und dann kann ein const HashTableObjekt weiterhin seine lookup()Methode verwenden, die den internen Cache ändert.

mutable existiert, wenn Sie daraus schließen, dass man Daten in einer ansonsten konstanten Funktion ändern kann.

Die Absicht ist, dass Sie möglicherweise eine Funktion haben, die "nichts" mit dem internen Status des Objekts tut, und Sie die Funktion markieren const, aber Sie müssen möglicherweise einige der Objektzustände so ändern, dass sie sich nicht auf den korrekten Status auswirken Funktionalität.

Das Schlüsselwort kann als Hinweis für den Compiler dienen. Ein theoretischer Compiler kann ein konstantes Objekt (z. B. ein globales Objekt) im Speicher ablegen, das als schreibgeschützt markiert wurde. Das Vorhandensein von mutableHinweisen, dass dies nicht getan werden sollte.

Hier einige gültige Gründe, um veränderbare Daten zu deklarieren und zu verwenden:

• Gewindesicherheit. A zu deklarieren mutable boost::mutexist völlig vernünftig.
• Statistiken. Zählen der Anzahl der Aufrufe einer Funktion anhand einiger oder aller ihrer Argumente.
• Auswendiglernen. Berechnen Sie eine teure Antwort und speichern Sie sie dann zum späteren Nachschlagen, anstatt sie erneut zu berechnen.

Nun ja, das ist es, was es tut. Ich verwende es für Mitglieder, die durch Methoden geändert werden, die den Status einer Klasse nicht logisch ändern - zum Beispiel, um die Suche durch Implementierung eines Caches zu beschleunigen:

class CIniWrapper
{
public:
   CIniWrapper(LPCTSTR szIniFile);

   // non-const: logically modifies the state of the object
   void SetValue(LPCTSTR szName, LPCTSTR szValue);

   // const: does not logically change the object
   LPCTSTR GetValue(LPCTSTR szName, LPCTSTR szDefaultValue) const;

   // ...

private:
   // cache, avoids going to disk when a named value is retrieved multiple times
   // does not logically change the public interface, so declared mutable
   // so that it can be used by the const GetValue() method
   mutable std::map<string, string> m_mapNameToValue;
};

Jetzt müssen Sie dies mit Vorsicht verwenden - Parallelitätsprobleme sind ein großes Problem, da ein Aufrufer möglicherweise davon ausgeht, dass sie threadsicher sind, wenn nur constMethoden verwendet werden. Und natürlich sollte das Ändern von mutableDaten das Verhalten des Objekts nicht wesentlich verändern. Dies könnte durch das von mir angegebene Beispiel verletzt werden, wenn beispielsweise erwartet würde, dass auf die Festplatte geschriebene Änderungen für die App sofort sichtbar sind .

Mutable wird verwendet, wenn Sie eine Variable innerhalb der Klasse haben, die nur innerhalb dieser Klasse verwendet wird, um Dinge wie beispielsweise einen Mutex oder eine Sperre zu signalisieren. Diese Variable ändert das Verhalten der Klasse nicht, ist jedoch erforderlich, um die Thread-Sicherheit der Klasse selbst zu implementieren. Ohne "veränderlich" könnten Sie also keine "const" -Funktionen haben, da diese Variable in allen Funktionen geändert werden muss, die der Außenwelt zur Verfügung stehen. Daher wurde mutable eingeführt, um eine Mitgliedsvariable auch durch eine const-Funktion beschreibbar zu machen.

Die angegebene veränderbare Variable informiert sowohl den Compiler als auch den Leser darüber, dass es sicher ist und erwartet wird, dass eine Mitgliedsvariable innerhalb einer const-Mitgliedsfunktion geändert werden kann.

mutable wird hauptsächlich für ein Implementierungsdetail der Klasse verwendet. Der Benutzer der Klasse muss nichts darüber wissen, daher ist die Methode, die er für "sollte" hält, const. Ihr Beispiel dafür, dass ein Mutex veränderlich ist, ist ein gutes kanonisches Beispiel.

Ihre Verwendung ist es nicht ein Hack, obwohl wie viele Dinge in C ++, wandelbar kann Hack für einen faulen Programmierer sein , wer möchte nicht den ganzen Weg zurück und markieren Sie etwas gehen , die nicht const als nicht-const sein sollte.

Verwenden Sie "veränderlich", wenn für Dinge, die für den Benutzer LOGISCH zustandslos sind (und daher "const" -Getter in den APIs der öffentlichen Klasse enthalten sollten), in der zugrunde liegenden IMPLEMENTATION (dem Code in Ihrer .cpp) jedoch NICHT zustandslos sind.

Die Fälle, in denen ich es am häufigsten verwende, sind die verzögerte Initialisierung zustandsloser "einfacher alter Daten" -Mitglieder. Es ist nämlich ideal in engen Fällen, in denen es teuer ist, solche Mitglieder entweder zu bauen (Prozessor) oder herumzutragen (Speicher), und viele Benutzer des Objekts niemals nach ihnen fragen werden. In dieser Situation möchten Sie eine verzögerte Konstruktion im Back-End für die Leistung, da 90% der erstellten Objekte sie niemals erstellen müssen und Sie dennoch die richtige zustandslose API für den öffentlichen Verbrauch präsentieren müssen.

Mutable ändert die Bedeutung constvon bitweiser Konstante in logische Konstante für die Klasse.

Dies bedeutet, dass Klassen mit veränderlichen Elementen länger bitweise konstant sind und nicht mehr in schreibgeschützten Abschnitten der ausführbaren Datei angezeigt werden.

Darüber hinaus wird die Typprüfung constgeändert , indem Elementfunktionen veränderbare Elemente ohne Verwendung ändern können const_cast.

class Logical {
    mutable int var;

public:
    Logical(): var(0) {}
    void set(int x) const { var = x; }
};

class Bitwise {
    int var;

public:
    Bitwise(): var(0) {}
    void set(int x) const {
        const_cast<Bitwise*>(this)->var = x;
    }
};

const Logical logical; // Not put in read-only.
const Bitwise bitwise; // Likely put in read-only.

int main(void)
{
    logical.set(5); // Well defined.
    bitwise.set(5); // Undefined.
}

Weitere Einzelheiten finden Sie in den anderen Antworten. Ich wollte jedoch hervorheben, dass dies nicht nur der Typensicherheit dient und sich auf das kompilierte Ergebnis auswirkt.

In einigen Fällen (wie bei schlecht gestalteten Iteratoren) muss die Klasse eine Zählung oder einen anderen zufälligen Wert beibehalten, der den Haupt- "Status" der Klasse nicht wirklich beeinflusst. Dies ist am häufigsten, wo ich veränderlich verwendet sehe. Ohne veränderlich wären Sie gezwungen, die gesamte Konstanz Ihres Designs zu opfern.

Es fühlt sich für mich auch die meiste Zeit wie ein Hack an. Nützlich in sehr wenigen Situationen.

Das klassische Beispiel (wie in anderen Antworten erwähnt) und die einzige Situation, in der ich das bisher mutableverwendete Schlüsselwort gesehen habe , ist das Zwischenspeichern des Ergebnisses eines kompliziertenGet Methode, bei der der Cache als Datenelement der Klasse und nicht als statische Variable in der Methode (aus Gründen der gemeinsamen Nutzung mehrerer Funktionen oder der einfachen Sauberkeit).

Im Allgemeinen sind die Alternativen zur Verwendung des mutableSchlüsselworts normalerweise eine statische Variable in der Methode oder im const_castTrick.

Eine weitere ausführliche Erklärung finden Sie hier .

Die veränderbare Variable kann nützlich sein, wenn Sie eine virtuelle const-Funktion überschreiben und Ihre untergeordnete Klassenmitgliedsvariable in dieser Funktion ändern möchten. In den meisten Fällen möchten Sie die Schnittstelle der Basisklasse nicht ändern, daher müssen Sie eine eigene veränderbare Mitgliedsvariable verwenden.

Das veränderbare Schlüsselwort ist sehr nützlich, wenn Sie Stubs für Klassentestzwecke erstellen. Sie können eine const-Funktion stubben und dennoch in der Lage sein, (veränderbare) Zähler oder andere Testfunktionen, die Sie Ihrem stub hinzugefügt haben, zu erhöhen. Dadurch bleibt die Schnittstelle der Stubbed-Klasse erhalten.

Eines der besten Beispiele, bei denen wir veränderlich verwenden, ist die tiefe Kopie. im Kopierkonstruktor senden wir const &objals Argument. Das neu erstellte Objekt ist also vom konstanten Typ. Wenn wir die Mitglieder in diesem neu erstellten const-Objekt ändern möchten (meistens werden wir sie nicht ändern, in seltenen Fällen können wir sie ändern), müssen wir es als deklarieren mutable.

mutableDie Speicherklasse kann nur für nicht statische nicht konstante Datenelemente einer Klasse verwendet werden. Das veränderbare Datenelement einer Klasse kann geändert werden, auch wenn es Teil eines Objekts ist, das als const deklariert ist.

class Test
{
public:
    Test(): x(1), y(1) {};
    mutable int x;
    int y;
};

int main()
{
    const Test object;
    object.x = 123;
    //object.y = 123;
    /* 
    * The above line if uncommented, will create compilation error.
    */   

    cout<< "X:"<< object.x << ", Y:" << object.y;
    return 0;
}

Output:-
X:123, Y:1

Im obigen Beispiel können wir den Wert der Mitgliedsvariablen ändern, xobwohl sie Teil eines Objekts ist, das als const deklariert ist. Dies liegt daran, dass die Variable xals veränderbar deklariert ist. Wenn Sie jedoch versuchen, den Wert der Mitgliedsvariablen zu ändern y, gibt der Compiler einen Fehler aus.

Das Schlüsselwort 'mutable' ist eigentlich ein reserviertes Schlüsselwort. Oft wird es verwendet, um den Wert der konstanten Variablen zu variieren. Wenn Sie mehrere Werte einer Konstante haben möchten, verwenden Sie das Schlüsselwort mutable.

//Prototype 
class tag_name{
                :
                :
                mutable var_name;
                :
                :
               };