const 成员函数修改成员变量 ​

面试考点 ​

面试官通过这道题考察你对 const 正确性的理解。核心问题是:const 成员函数承诺不修改对象状态,但有时确实需要修改某些内部变量(如缓存、访问计数),怎么办?答案是 mutable 关键字。

核心概念 ​

const 成员函数中,this 指针的类型是 const T*,所以不能修改任何成员变量。但用 mutable 修饰的成员变量是例外——它可以在 const 成员函数中被修改。这体现了"逻辑 const"和"物理 const"的区别。

基本示例 ​

cpp
#include <iostream>
#include <string>
#include <mutex>
#include <map>

// ============================
// 示例1:mutable 基本用法
// ============================

class Counter {
    int value_;
    mutable int access_count_;  // mutable:可在 const 函数中修改
public:
    Counter(int v) : value_(v), access_count_(0) {}

    // const 成员函数:承诺不修改对象的"可观察状态"
    int get_value() const {
        access_count_++;          // OK:mutable 成员可以修改
        // value_ = 100;          // 编译错误:非 mutable 成员不能修改
        return value_;
    }

    int get_access_count() const {
        return access_count_;
    }
};

void mutable_basic_demo() {
    const Counter c(42);         // const 对象
    std::cout << "值: " << c.get_value() << std::endl;
    std::cout << "值: " << c.get_value() << std::endl;
    std::cout << "访问次数: " << c.get_access_count() << std::endl;  // 2
}

// ============================
// 示例2:缓存场景(最典型的 mutable 用途)
// ============================

class ExpensiveData {
    std::string raw_data_;
    mutable bool cache_valid_;        // 缓存是否有效
    mutable std::string cached_result_; // 缓存的结果
public:
    ExpensiveData(const std::string& data)
        : raw_data_(data), cache_valid_(false) {}

    // 对外是 const 操作(不改变可观察状态)
    // 但内部会更新缓存(修改 mutable 成员)
    std::string process() const {
        if (!cache_valid_) {
            // 模拟耗时计算
            cached_result_ = "processed: " + raw_data_;
            cache_valid_ = true;
            std::cout << "  [执行计算]" << std::endl;
        } else {
            std::cout << "  [使用缓存]" << std::endl;
        }
        return cached_result_;
    }

    void set_data(const std::string& data) {
        raw_data_ = data;
        cache_valid_ = false;  // 数据变了,缓存失效
    }
};

void cache_demo() {
    ExpensiveData data("hello");
    std::cout << data.process() << std::endl;  // 执行计算
    std::cout << data.process() << std::endl;  // 使用缓存

    data.set_data("world");
    std::cout << data.process() << std::endl;  // 数据变了,重新计算
}

// ============================
// 示例3:线程安全的 const(mutable mutex)
// ============================

class ThreadSafeConfig {
    std::map<std::string, std::string> config_;
    mutable std::mutex mutex_;  // mutable:const 函数中也要加锁
public:
    void set(const std::string& key, const std::string& value) {
        std::lock_guard<std::mutex> lock(mutex_);
        config_[key] = value;
    }

    // const 函数需要加锁保证线程安全
    // mutex::lock() 不是 const 的,所以 mutex 必须是 mutable
    std::string get(const std::string& key) const {
        std::lock_guard<std::mutex> lock(mutex_);  // mutable mutex
        auto it = config_.find(key);
        if (it != config_.end()) {
            return it->second;
        }
        return "";
    }
};

// ============================
// 示例4:const_cast(另一种方式,不推荐)
// ============================

class BadExample {
    int value_;
public:
    BadExample(int v) : value_(v) {}

    int get_value() const {
        // 用 const_cast 去掉 this 的 const——危险做法
        // 如果对象本身是 const 的,这是未定义行为!
        // const_cast<BadExample*>(this)->value_ = 100;
        return value_;
    }
};

void const_cast_warning() {
    // 对象不是 const 的——const_cast 技术上可以工作
    BadExample b1(42);
    // 但如果对象本身是 const 的——未定义行为
    // const BadExample b2(42);
    // b2.get_value();  // 如果内部 const_cast 修改了成员,是 UB

    std::cout << "const_cast 修改 const 对象的成员是未定义行为" << std::endl;
}

// ============================
// 示例5:逻辑 const vs 物理 const
// ============================

class Document {
    std::string content_;
    mutable int view_count_;       // 查看次数不影响文档内容
    mutable std::string cache_;    // 缓存不影响文档的逻辑状态
public:
    Document(const std::string& content)
        : content_(content), view_count_(0) {}

    // 逻辑上是 const 的(文档内容没变)
    // 物理上修改了 view_count_ 和 cache_
    std::string view() const {
        view_count_++;
        if (cache_.empty()) {
            cache_ = "[渲染] " + content_;
        }
        return cache_;
    }

    int get_view_count() const { return view_count_; }
};

void logical_const_demo() {
    const Document doc("Hello World");
    std::cout << doc.view() << std::endl;
    std::cout << doc.view() << std::endl;
    std::cout << "查看次数: " << doc.get_view_count() << std::endl;
}

int main() {
    std::cout << "=== mutable 基本用法 ===" << std::endl;
    mutable_basic_demo();

    std::cout << "\n=== 缓存场景 ===" << std::endl;
    cache_demo();

    std::cout << "\n=== const_cast 警告 ===" << std::endl;
    const_cast_warning();

    std::cout << "\n=== 逻辑 const ===" << std::endl;
    logical_const_demo();

    return 0;
}

mutable vs const_cast ​

特性mutableconst_cast
声明位置成员变量声明时使用时
安全性安全(编译器知道)危险(可能是 UB)
语义逻辑 const 的一部分绕过 const 系统
对 const 对象安全修改 mutable 成员修改可能是 UB
推荐度推荐不推荐

常见问题 ​

mutable 可以用在 static 成员上吗?

不可以。mutable 只能用于非静态、非 const 的数据成员。static 成员不属于对象,const 成员函数的限制不适用于它。

什么场景适合用 mutable?

典型场景:缓存(cached result)、访问计数、延迟初始化、互斥锁(mutex)。共同点是:这些修改不影响对象的"可观察状态",外部看来对象没变。

mutable 和线程安全有什么关系?

C++ 标准规定:const 成员函数应该是线程安全的(可以被多线程同时调用)。如果 const 函数修改了 mutable 成员,需要用 mutable mutex 保护这些修改。

适用场景 ​

  • 缓存计算结果
  • 访问统计计数
  • 延迟初始化(lazy initialization)
  • const 函数中的互斥锁
  • 调试用的日志成员

注意事项 ​

  • mutable 应该只用于不影响对象可观察状态的成员
  • 不要滥用 mutable 来绕过 const 正确性
  • const_cast 修改实际为 const 的对象是未定义行为
  • mutable 成员在多线程环境下需要同步保护
  • mutable 不能用于 static 成员和 const 成员

总结 ​

const 成员函数中修改成员变量的正确方式是使用 mutable 关键字。mutable 标记的成员可以在 const 函数中被修改,用于缓存、计数、互斥锁等不影响对象可观察状态的场景。这体现了"逻辑 const"(对外不变)和"物理 const"(内部可变)的区别。另一种方式 const_cast 可以去掉 const 限制,但如果对象本身是 const 的,修改它是未定义行为,所以不推荐使用。面试中要能解释 mutable 的用途、与 const_cast 的区别,以及在多线程环境下 mutable 成员需要同步保护。