const 成员函数修改成员变量
面试考点
面试官通过这道题考察你对 const 正确性的理解。核心问题是:const 成员函数承诺不修改对象状态,但有时确实需要修改某些内部变量(如缓存、访问计数),怎么办?答案是 mutable 关键字。
核心概念
const 成员函数中,this 指针的类型是 const T*,所以不能修改任何成员变量。但用 mutable 修饰的成员变量是例外——它可以在 const 成员函数中被修改。这体现了"逻辑 const"和"物理 const"的区别。
基本示例
#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
| 特性 | mutable | const_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 成员需要同步保护。