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 modifier aucune variable membre. Mais vous devez parfois 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 imposée par 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 peut être modifié même lorsque l’objet est considéré comme const. »

Les cas d’utilisation courants de mutable incluent la mise en cache des 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 constitue des métadonnées 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 devrait être appliqué qu’aux membres qui n’affectent pas l’état observable de l’objet.

Défi

Facile

Construisons un lecteur de documents qui suit le nombre de fois qu’un document a été consulté, sans compromettre la const-correction de nos méthodes en lecture seule. C’est un cas d’utilisation idéal du 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 discrètement les statistiques de consultation. Votre classe doit contenir :
- Membres privés : title (chaîne de caractères), content (chaîne de caractères) 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, en initialisant viewCount à 0
- Une méthode const getTitle() qui renvoie le titre
- Une méthode const getContent() qui incrémente viewCount (ce qui est autorisé puisqu’il est mutable) et renvoie le contenu
- Une méthode const getViewCount() qui renvoie le nombre de fois que le contenu a été consulté
- Une méthode const getPreview() qui renvoie les 20 premiers caractères du contenu suivis de "...". Cette méthode ne doit PAS incrémenter le nombre de consultations puisqu’il s’agit seulement d’un aperçu
main.cpp : montrez comment mutable permet de suivre les statistiques d’accès tout en conservant des méthodes logiquement const. Lisez le titre et le contenu d’un document depuis l’entrée (chacun sur une ligne distincte), puis :
- Créez un Document avec les valeurs saisies
- Affichez "Title: <title>"
- Affichez "Preview: <preview>"
- Affichez "Views after preview: <count>"
- Accédez au contenu complet à l’aide de getContent() et affichez "Content: <content>"
- Affichez "Views after first read: <count>"
- Accédez de nouveau au contenu et affichez "Content: <content>"
- Affichez "Views after second read: <count>"
- Créez une fonction auxiliaire 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 nombre de consultations doit être de 0 après l’aperçu (puisque les aperçus ne comptent pas comme des consultations complètes), puis s’incrémenter chaque fois que getContent() est appelée. Le mot-clé mutable rend cela possible : sans lui, vous ne pourriez pas modifier viewCount dans des méthodes const telles que getContent().

Si le contenu comporte moins de 20 caractères, getPreview() doit renvoyer l’intégralité du contenu suivie de "...".

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: Print "Views after preview: <count>"
    
    // TODO: Accéder au contenu complet et afficher "Content: <content>"
    
    // TODO: Print "Views after first read: <count>"
    
    // TODO: Accéder à nouveau au contenu et afficher "Content: <content>"
    
    // TODO: Print "Views after second read: <count>"
    
    // TODO: Appeler displayDocument() avec votre document
    
    // TODO: Print "Final view count: <count>"
    
    return 0;
}