Le mot-clé 'mutable' a-t-il un but autre que de permettre à la variable d'être modifiée par une fonction const?

Il y a quelque temps, je suis tombé sur du code qui marquait une variable membre d'une classe avec le mutablemot - clé. Pour autant que je sache, cela vous permet simplement de modifier une variable dans une constméthode:

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

Est-ce la seule utilisation de ce mot-clé ou y a-t-il plus que ce qui semble évident? Depuis, j'ai utilisé cette technique dans une classe, marquant une boost::mutexfonction mutable permettant constde la verrouiller pour des raisons de sécurité des threads, mais, pour être honnête, cela ressemble à un hack.

Il permet la différenciation de const au niveau du bit et de const logique. La const logique est lorsqu'un objet ne change pas d'une manière visible à travers l'interface publique, comme votre exemple de verrouillage. Un autre exemple serait une classe qui calcule une valeur la première fois qu'elle est demandée et met en cache le résultat.

Puisque c ++ 11 mutablepeut être utilisé sur un lambda pour indiquer que les choses capturées par valeur sont modifiables (elles ne le sont pas par défaut):

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

Le mutablemot-clé est un moyen de percer le constvoile que vous drapez sur vos objets. Si vous avez une référence const ou un pointeur vers un objet, vous ne pouvez en aucun cas modifier cet objet sauf quand et comment il est marqué mutable.

Avec votre constréférence ou votre pointeur, vous êtes contraint de:

• accès en lecture uniquement aux membres de données visibles
• autorisation d'appeler uniquement les méthodes marquées comme const.

Grâce à l' mutableexception, vous pouvez désormais écrire ou définir des membres de données marqués mutable. C'est la seule différence visible de l'extérieur.

En interne, les constméthodes visibles par vous peuvent également écrire sur les membres de données marqués mutable. Essentiellement, le voile const est percé de manière complète. Il appartient entièrement au concepteur d'API de s'assurer que mutablecela ne détruit pas le constconcept et n'est utilisé que dans des cas spéciaux utiles. Le mutablemot-clé est utile car il marque clairement les membres de données qui sont soumis à ces cas particuliers.

En pratique, vous pouvez utiliser de manière constobsessionnelle tout au long de votre base de code (vous voulez essentiellement "infecter" votre base de code avec leconst "maladie"). Dans ce monde, les pointeurs et les références sont constà de très rares exceptions près, produisant un code plus facile à raisonner et à comprendre. Pour une digression intéressante, recherchez "transparence référentielle".

Sans le mutablemot - clé, vous serez éventuellement contraint d'utiliser const_castpour gérer les différents cas spéciaux utiles qu'il permet (mise en cache, comptage de références, données de débogage, etc.). Malheureusement, il const_castest beaucoup plus destructeur que mutableparce qu'il oblige le client API à détruire la constprotection des objets qu'il utilise. De plus, il provoque une constdestruction généralisée : const_castun pointeur ou une référence const permet une écriture et une méthode d'appel sans entrave donnant accès aux membres visibles. En revanche, mutablele concepteur d'API doit exercer un contrôle fin sur les constexceptions, et généralement ces exceptions sont masquées dansconst méthodes fonctionnant sur des données privées.

(NB je me réfère à la visibilité des données et des méthodes à quelques reprises. Je parle des membres marqués comme public vs privé ou protégé qui est un type totalement différent de protection d'objet discuté ici .)

Votre utilisation avec boost :: mutex est exactement à quoi ce mot-clé est destiné. Une autre utilisation est la mise en cache des résultats internes pour accélérer l'accès.

Fondamentalement, «mutable» s'applique à tout attribut de classe qui n'affecte pas l'état visible de l'extérieur de l'objet.

Dans l'exemple de code dans votre question, mutable peut être inapproprié si la valeur de done_ affecte l'état externe, cela dépend de ce qui est dans le ...; partie.

Mutable sert à marquer un attribut spécifique comme modifiable à partir de constméthodes internes . C'est son seul but. Réfléchissez bien avant de l'utiliser, car votre code sera probablement plus propre et plus lisible si vous modifiez la conception plutôt que de l'utilisermutable .

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

Donc, si la folie ci-dessus n'est pas à quoi sert le mutable, à quoi sert-elle? Voici le cas subtil: mutable est le cas où un objet est logiquement constant, mais en pratique doit changer. Ces cas sont rares, mais ils existent.

Les exemples que l'auteur donne incluent la mise en cache et les variables de débogage temporaires.

Il est utile dans les situations où vous avez caché un état interne tel qu'un cache. Par exemple:

classe HashTable
{
...
Publique:
    recherche de chaîne (clé de chaîne) const
    {
        if (key == lastKey)
            return lastValue;

        valeur de chaîne = lookupInternal (clé);

        lastKey = clé;
        lastValue = valeur;

        valeur de retour;
    }

privé:
    chaîne mutable lastKey, lastValue;
};

Et puis, vous pouvez faire en sorte qu'un const HashTableobjet utilise toujours sa lookup()méthode, qui modifie le cache interne.

mutable existe comme vous le déduisez pour permettre de modifier les données dans une fonction par ailleurs constante.

L'intention est que vous puissiez avoir une fonction qui "ne fait rien" à l'état interne de l'objet, et donc vous marquez la fonction const, mais vous devrez peut-être vraiment modifier certains des objets de manière à ne pas affecter son bon Fonctionnalité.

Le mot-clé peut agir comme un indice pour le compilateur - un compilateur théorique pourrait placer un objet constant (tel qu'un global) dans la mémoire qui a été marqué en lecture seule. La présence d' mutableindices que cela ne devrait pas être fait.

Voici quelques raisons valables pour déclarer et utiliser des données mutables:

• Sécurité des fils. Déclarer un mutable boost::mutexest parfaitement raisonnable.
• Statistiques. Compter le nombre d'appels à une fonction, compte tenu de tout ou partie de ses arguments.
• Mémorisation. Calculer une réponse coûteuse, puis la stocker pour référence future plutôt que de la recalculer à nouveau.

Eh bien, oui, c'est ce que ça fait. Je l'utilise pour les membres modifiés par des méthodes qui ne changent pas logiquement l'état d'une classe - par exemple, pour accélérer les recherches en implémentant un cache:

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

Maintenant, vous devez l'utiliser avec précaution - les problèmes de concurrence sont une grande préoccupation, car un appelant peut supposer qu'ils sont sûrs pour les threads uniquement en utilisant des constméthodes. Et bien sûr, la modification des mutabledonnées ne devrait pas changer le comportement de l'objet de manière significative, quelque chose qui pourrait être violé par l'exemple que j'ai donné si, par exemple, on s'attendait à ce que les modifications écrites sur le disque soient immédiatement visibles par l'application .

Mutable est utilisé lorsque vous avez une variable à l'intérieur de la classe qui n'est utilisée que dans cette classe pour signaler des choses comme par exemple un mutex ou un verrou. Cette variable ne modifie pas le comportement de la classe, mais est nécessaire pour implémenter la sécurité des threads de la classe elle-même. Ainsi, sans "mutable", vous ne pourriez pas avoir de fonctions "const" car cette variable devra être modifiée dans toutes les fonctions disponibles pour le monde extérieur. Par conséquent, mutable a été introduit afin de rendre une variable membre accessible en écriture même par une fonction const.

Le mutable spécifié informe le compilateur et le lecteur qu'il est sûr et attendu qu'une variable membre peut être modifiée dans une fonction membre const.

mutable est principalement utilisé sur un détail d'implémentation de la classe. L'utilisateur de la classe n'a pas besoin de le savoir, donc la méthode qu'il pense "devrait" être const peut l'être. Votre exemple d'avoir un mutex mutable est un bon exemple canonique.

Votre utilisation de celui-ci n'est pas un hack, bien que comme beaucoup de choses en C ++, mutable peut être piraté pour un programmeur paresseux qui ne veut pas revenir en arrière et marquer quelque chose qui ne devrait pas être const comme non-const.

Utilisez "mutable" lorsque pour des choses qui sont LOGICALEMENT sans état pour l'utilisateur (et doivent donc avoir des getters "const" dans les API de la classe publique) mais ne sont PAS sans état dans la MISE EN ŒUVRE sous-jacente (le code dans votre .cpp).

Les cas où je l'utilise le plus souvent sont l'initialisation paresseuse de membres "sans données anciennes" sans état. À savoir, il est idéal dans les cas étroits où de tels membres sont coûteux à construire (processeur) ou à transporter (mémoire) et de nombreux utilisateurs de l'objet ne les demanderont jamais. Dans cette situation, vous voulez une construction paresseuse à l'arrière pour les performances, car 90% des objets construits n'auront jamais besoin de les construire, mais vous devez toujours présenter la bonne API sans état pour la consommation publique.

Mutable change la signification de constconst au niveau du bit en const logique pour la classe.

Cela signifie que les classes avec des membres mutables sont plus constantes au niveau du bit et n'apparaissent plus dans les sections en lecture seule de l'exécutable.

De plus, il modifie la vérification de type en permettant constaux fonctions membres de changer les membres mutables sans utiliser 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.
}

Voir les autres réponses pour plus de détails, mais je voulais souligner que ce n'est pas seulement pour la sécurité de type et qu'il affecte le résultat compilé.

Dans certains cas (comme les itérateurs mal conçus), la classe doit garder un décompte ou une autre valeur incidente, qui n'affecte pas vraiment le "principal" état de la classe. C'est le plus souvent où je vois mutable utilisé. Sans mutable, vous seriez obligé de sacrifier toute la constance de votre conception.

Cela ressemble aussi à un hack la plupart du temps pour moi. Utile dans très très peu de situations.

L'exemple classique (comme mentionné dans d'autres réponses) et la seule situation dans laquelle j'ai vu le mutablemot - clé utilisé jusqu'à présent est la mise en cache du résultat d'une Getméthode compliquée , où le cache est implémenté en tant que membre de données de la classe et non en tant que variable statique dans la méthode (pour des raisons de partage entre plusieurs fonctions ou de propreté absolue).

En général, les alternatives à l'utilisation du mutablemot-clé sont généralement une variable statique dans la méthode ou l' const_castastuce.

Une autre explication détaillée se trouve ici .

Le mutable peut être pratique lorsque vous remplacez une fonction virtuelle const et que vous souhaitez modifier votre variable membre de classe enfant dans cette fonction. Dans la plupart des cas, vous ne voudriez pas modifier l'interface de la classe de base, vous devez donc utiliser votre propre variable membre mutable.

Le mot clé mutable est très utile lors de la création de stubs à des fins de test de classe. Vous pouvez stub une fonction const et toujours être en mesure d'augmenter les compteurs (mutables) ou n'importe quelle fonctionnalité de test que vous avez ajoutée à votre stub. Cela conserve l'interface de la classe tronquée intacte.

L'un des meilleurs exemples où nous utilisons mutable est, en copie profonde. dans le constructeur de copie, nous envoyons const &objcomme argument. Le nouvel objet créé sera donc de type constant. Si nous voulons changer (surtout nous ne changerons pas, dans de rares cas nous pouvons changer) les membres de cet objet const nouvellement créé, nous devons le déclarer comme mutable.

mutableLa classe de stockage ne peut être utilisée que sur un membre de données non statique et non const d'une classe. Le membre de données mutable d'une classe peut être modifié même s'il fait partie d'un objet déclaré comme const.

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

Dans l'exemple ci-dessus, nous pouvons changer la valeur de la variable membre xbien qu'elle fasse partie d'un objet qui est déclaré const. En effet, la variable xest déclarée comme mutable. Mais si vous essayez de modifier la valeur de la variable membre y, le compilateur lèvera une erreur.

Le mot-clé même "mutable" est en fait un mot-clé réservé. Souvent, il est utilisé pour faire varier la valeur d'une variable constante. Si vous voulez avoir plusieurs valeurs d'une constante, utilisez le mot-clé mutable.

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