C++ mutable 的功能和用法

mutable 是C++ 中的关键字，用于在 const 成员函数中修改成员变量，允许特定成员变量即便在 const 对象或 const 成员函数中也能被改变。

1. 核心功能

突破const限制：能在 const 成员函数中对被 mutable 修饰的成员变量进行修改。
保持逻辑常性：允许修改不影响对象“逻辑状态”的内部实现细节。

2. 基本用法

class Example {
private:
    mutable int cache;  // 即使const函数也可修改
    int value;

public:
    Example(int v) : value(v), cache(0) {}

    int getValue() const {
        // 虽然函数是const，但可以修改mutable成员
        if (cache == 0) {
            cache = value * 2;  // 修改mutable成员，合法
        }
        return cache;
    }
};

3. 常见应用场景

3.1. 缓存机制

class DataProcessor {
private:
    mutable int resultCache;
    mutable bool cacheValid;
    int rawData;

public:
    DataProcessor(int data) : rawData(data), resultCache(0), cacheValid(false) {}

    int getProcessedResult() const {
        if (!cacheValid) {
            // 耗时的计算
            resultCache = rawData * 100 + 50;
            cacheValid = true;
        }
        return resultCache;
    }

    void updateData(int newData) {
        rawData = newData;
        cacheValid = false;  // 数据改变，使缓存失效
    }
};

3.2. 互斥锁

#include <mutex>

class ThreadSafeCounter {
private:
    mutable std::mutex mtx;
    int count;

public:
    ThreadSafeCounter() : count(0) {}

    int getCount() const {
        std::lock_guard<std::mutex> lock(mtx);  // const函数中锁mutex
        return count;
    }

    void increment() {
        std::lock_guard<std::mutex> lock(mtx);
        ++count;
    }
};

3.3. 引用计数或调试信息

class Resource {
private:
    mutable int accessCount;  // 跟踪访问次数
    int data;

public:
    Resource(int d) : data(d), accessCount(0) {}

    int getData() const {
        ++accessCount;  // 记录访问次数，不影响逻辑状态
        return data;
    }

    int getAccessCount() const {
        return accessCount;
    }
};

4. 重要注意事项

不能用于静态成员

class MyClass {
    mutable static int x;  // ❌ 错误：mutable不能用于静态成员
    static int y;          // ✅ 静态成员不需要mutable
};

不能用于引用成员

1
2
3

class MyClass {
    mutable int& ref;  // ❌ 错误：mutable不能用于引用
};

不能用于const成员

1
2
3

class MyClass {
    mutable const int x;  // ❌ 错误：不能同时为const和mutable
};

5. 设计原则

使用 mutable 需遵循逻辑常性原则：

对象“逻辑状态”保持不变。
修改的仅是“物理状态”或实现细节。
不影响对象公开行为。

class GoodDesign {
private:
    mutable std::string logBuffer;  // 日志缓冲区
    mutable int debugCounter;        // 调试计数器
    int importantData;               // 真正的业务数据

public:
    // const函数中记录调试信息，不影响业务逻辑
    void process() const {
        debugCounter++;  // 合理：调试信息不影响对象状态
        // importantData++;  // 错误：这会改变对象逻辑状态
    }
};