不久前，我遇到了一些代码，它们用mutable关键字标记了一个类的成员变量。据我所知，它只是允许你在const方法中修改变量:
class Foo
{
private:
mutable bool done_;
public:
void doSomething() const { ...; done_ = true; }
};
这是唯一的使用这个关键字还是有更多的它比满足眼睛?从那以后，我在一个类中使用了这种技术，将boost::mutex标记为mutable，允许const函数出于线程安全的原因锁定它，但是，说实话，这感觉有点hack。
当前回答
Mutable is used when you have a variable inside the class that is only used within that class to signal things like for example a mutex or a lock. This variable does not change the behaviour of the class, but is necessary in order to implement thread safety of the class itself. Thus if without "mutable", you would not be able to have "const" functions because this variable will need to be changed in all functions that are available to the outside world. Therefore, mutable was introduced in order to make a member variable writable even by a const function.
指定的可变变量通知编译器和读取器 成员变量可以在const中修改，这是安全和预期的吗 成员函数。
其他回答
你对它的使用并不是一种hack，尽管像c++中的许多东西一样，mutable对于懒惰的程序员来说是一种hack，他们不想从头开始并将不应该是const的东西标记为非const。
对于那些对用户来说是逻辑上无状态的东西(因此在公共类的api中应该有“const”getter)，但在底层实现(你的.cpp中的代码)中不是无状态的东西，使用“mutable”。
The cases I use it most frequently are lazy initialization of state-less "plain old data" members. Namely, it is ideal in the narrow cases when such members are expensive to either build (processor) or carry around (memory) and many users of the object will never ask for them. In that situation you want lazy construction on the back end for performance, since 90% of the objects built will never need to build them at all, yet you still need to present the correct stateless API for public consumption.
是的，这就是它的作用。我将它用于那些被方法修改的成员，而这些方法在逻辑上不会改变类的状态——例如，通过实现缓存来加速查找:
class CIniWrapper
{
public:
CIniWrapper(LPCTSTR szIniFile);
// non-const: logically modifies the state of the object
void SetValue(LPCTSTR szName, LPCTSTR szValue);
// const: does not logically change the object
LPCTSTR GetValue(LPCTSTR szName, LPCTSTR szDefaultValue) const;
// ...
private:
// cache, avoids going to disk when a named value is retrieved multiple times
// does not logically change the public interface, so declared mutable
// so that it can be used by the const GetValue() method
mutable std::map<string, string> m_mapNameToValue;
};
现在，你必须小心使用它——并发性问题是一个大问题，因为如果只使用const方法，调用者可能会认为它们是线程安全的。当然，修改可变数据不应该以任何重要的方式改变对象的行为，我给出的例子可能违反了这一点，例如，如果期望写入磁盘的更改将立即对应用程序可见。
使用可变的一个最好的例子是，在深度复制中。在复制构造函数中，我们发送const &obj作为参数。因此，新创建的对象将是常量类型。如果我们想要改变这个新创建的const对象中的成员(大多数情况下我们不会改变，在极少数情况下我们可能会改变)，我们需要将它声明为mutable。
可变存储类只能用于类的非静态非const数据成员。类的Mutable数据成员可以被修改，即使它是声明为const的对象的一部分。
class Test
{
public:
Test(): x(1), y(1) {};
mutable int x;
int y;
};
int main()
{
const Test object;
object.x = 123;
//object.y = 123;
/*
* The above line if uncommented, will create compilation error.
*/
cout<< "X:"<< object.x << ", Y:" << object.y;
return 0;
}
Output:-
X:123, Y:1
在上面的例子中，我们能够改变成员变量x的值，尽管它是声明为const的对象的一部分。这是因为变量x声明为可变的。但是如果你试图修改成员变量y的值，编译器会抛出一个错误。
它允许区分按位的const和逻辑的const。逻辑const是指对象没有以通过公共接口可见的方式更改，就像锁定示例一样。另一个例子是一个类，它在第一次请求时计算一个值，并缓存结果。
因为c++11 mutable可以用在lambda上，表示用value捕获的东西是可修改的(默认情况下不是):
int x = 0;
auto f1 = [=]() mutable {x = 42;}; // OK
auto f2 = [=]() {x = 42;}; // Error: a by-value capture cannot be modified in a non-mutable lambda
