Mot-clé mutable

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy — leçon 30 sur 104.

Vous avez appris que les fonctions membres const ne peuvent pas modifier les variables membres. Mais parfois, vous devez modifier un membre qui n'affecte pas l'état logique de l'objet - comme un cache ou un compteur d'accès. Le mot-clé mutable fournit une exception à la restriction const.

Un membre mutable peut être modifié même à l'intérieur d'une fonction membre const :

class DataFetcher {
    std::string data;
    mutable int accessCount;    // Peut être modifié dans les fonctions const
    
public:
    DataFetcher(std::string d) : data(d), accessCount(0) {}
    
    std::string getData() const {
        accessCount++;          // Autorisé car accessCount est mutable
        return data;
    }
    
    int getAccessCount() const {
        return accessCount;
    }
};

Sans mutable, incrémenter accessCount à l'intérieur de la fonction const getData() provoquerait une erreur de compilation. Le mot-clé mutable indique au compilateur : « Ce membre est autorisé à changer même lorsque l'objet est considéré comme const. »

Les cas d'utilisation courants pour mutable incluent la mise en cache de valeurs calculées, le suivi des statistiques d'accès et les primitives de synchronisation comme les mutex. Dans chaque cas, la modification ne change pas ce que l'objet représente logiquement — une valeur mise en cache n'est qu'une optimisation, et un compteur d'accès est une métadonnée sur l'utilisation.

class Circle {
    double radius;
    mutable double cachedArea;
    mutable bool areaCached;
    
public:
    double getArea() const {
        if (!areaCached) {
            cachedArea = 3.14159 * radius * radius;
            areaCached = true;
        }
        return cachedArea;
    }
};

Utilisez mutable avec parcimonie - il ne doit être appliqué qu'aux membres qui n'affectent pas l'état observable de l'objet.

Défi

Facile

Construisons une visionneuse de documents qui suit le nombre de fois qu'un document a été consulté — sans rompre la correction de constance (const-correctness) de nos méthodes en lecture seule. C'est un cas d'utilisation parfait pour le mot-clé mutable.

Vous allez créer deux fichiers pour organiser votre code :

Document.h : Définissez une classe Document qui stocke le contenu et suit secrètement les statistiques de consultation. Votre classe a besoin de :
- Membres privés : title (string), content (string), et un mutable int viewCount qui peut être modifié même dans les méthodes const
- Un constructeur qui prend un titre et un contenu, initialisant viewCount à 0
- Une méthode const getTitle() qui retourne le titre
- Une méthode const getContent() qui incrémente viewCount (autorisé car il est mutable) et retourne le contenu
- Une méthode const getViewCount() qui retourne le nombre de fois que le contenu a été accédé
- Une méthode const getPreview() qui retourne les 20 premiers caractères du contenu suivis de "..." — cela ne doit PAS incrémenter le compteur de vues car il s'agit d'un simple aperçu
main.cpp : Démontrez comment mutable permet de suivre les statistiques d'accès tout en gardant les méthodes logiquement const. Lisez un titre et un contenu de document à partir de l'entrée (chacun sur une ligne séparée), puis :
- Créez un Document avec les valeurs d'entrée
- Affichez "Title: <title>"
- Affichez "Preview: <preview>"
- Affichez "Views after preview: <count>"
- Accédez au contenu complet en utilisant getContent() et affichez "Content: <content>"
- Affichez "Views after first read: <count>"
- Accédez à nouveau au contenu et affichez "Content: <content>"
- Affichez "Views after second read: <count>"
- Créez une fonction utilitaire void displayDocument(const Document& doc) qui affiche "[Const Access] <title>: <content>" — cela prouve que nos méthodes const fonctionnent avec des références const
- Appelez displayDocument() avec votre document
- Affichez "Final view count: <count>"

Le compteur de vues doit être 0 après l'aperçu (car les aperçus ne comptent pas comme des vues complètes), puis s'incrémenter à chaque fois que getContent() est appelé. Le mot-clé mutable rend cela possible — sans lui, vous ne pourriez pas modifier viewCount à l'intérieur de méthodes const comme getContent().

Si le contenu fait moins de 20 caractères, getPreview() doit retourner le contenu entier suivi de "...".

Aide-mémoire

Le mot-clé mutable permet de modifier une variable membre même à l'intérieur de fonctions membres const :

class DataFetcher {
    std::string data;
    mutable int accessCount;    // Peut être modifié dans les fonctions const
    
public:
    DataFetcher(std::string d) : data(d), accessCount(0) {}
    
    std::string getData() const {
        accessCount++;          // Autorisé car accessCount est mutable
        return data;
    }
    
    int getAccessCount() const {
        return accessCount;
    }
};

Sans mutable, la modification d'une variable membre à l'intérieur d'une fonction const provoquerait une erreur de compilation. Le mot-clé indique au compilateur que ce membre est autorisé à changer même lorsque l'objet est considéré comme const.

Les cas d'utilisation courants incluent la mise en cache de valeurs calculées, le suivi des statistiques d'accès et les primitives de synchronisation. La modification ne doit pas changer ce que l'objet représente logiquement :

class Circle {
    double radius;
    mutable double cachedArea;
    mutable bool areaCached;
    
public:
    double getArea() const {
        if (!areaCached) {
            cachedArea = 3.14159 * radius * radius;
            areaCached = true;
        }
        return cachedArea;
    }
};

Utilisez mutable avec parcimonie - uniquement pour les membres qui n'affectent pas l'état observable de l'objet.

Essayez vous-même

#include <iostream>
#include <string>
#include "Document.h"
using namespace std;

// TODO: Implémenter la fonction displayDocument
// Elle doit afficher : "[Const Access] <title>: <content>"
void displayDocument(const Document& doc) {
    // TODO: Implémenter cette fonction
}

int main() {
    // Lire l'entrée
    string title;
    string content;
    getline(cin, title);
    getline(cin, content);
    
    // TODO: Créer un Document avec les valeurs d'entrée
    
    // TODO: Afficher "Title: <title>"
    
    // TODO: Afficher "Preview: <preview>"
    
    // TODO: Afficher "Views after preview: <count>"
    
    // TODO: Accéder au contenu complet et afficher "Content: <content>"
    
    // TODO: Afficher "Views after first read: <count>"
    
    // TODO: Accéder à nouveau au contenu et afficher "Content: <content>"
    
    // TODO: Afficher "Views after second read: <count>"
    
    // TODO: Appeler displayDocument() avec votre document
    
    // TODO: Afficher "Final view count: <count>"
    
    return 0;
}