C++关键字mutable和volatile

mutable和volatile

       很少遇到这两个关键字，学嵌入式估计知道后者，深入研究 C++ 的估计知道前者。

     (1)mutable

       在 C++ 中，mutable 是为了突破 const 的限制而设置的。被 mutable 修饰的变量，将永远处于可变的状态，即使在一个 const 函数中，甚至结构体变量或者类对象为 const，其 mutable 成员也可以被修改。

[cpp]  view plain  copy

 print?

1. struct  ST  
2.   
3. {  
4.   
5.   int a;  
6.   
7.   mutable int b;  
8.   
9. };  
10.   
11. const ST st={1,2};  
12.   
13. st.a=11;//编译错误  
14.   
15. st.b=22;//允许  

       mutable 在类中只能够修饰非静态数据成员。mutable 数据成员的使用看上去像是骗术，因为它能够使 const 函数修改对象的数据成员。然而，明智地使用 mutable 关键字可以提高代码质量，因为它能够让你向用户隐藏实现细节，而无须使用不确定的东西。我们知道，如果类的成员函数不会改变对象的状态，那么这个成员函数一般会声明成 const 的。但是，有些时候，我们需要在 const 的函数里面修改一些跟类状态无关的数据成员，那么这个数据成员就应该被 mutalbe 来修饰。

[cpp]  view plain  copy

 print?

1. class  ST  
2.   
3. {  
4.   
5. int a;  
6.   
7. mutable int showCount;  
8.   
9. void Show()const;  
10.   
11. …  
12.   
13. };  
14.   
15. ST::Show()  
16.   
17. {  
18.   
19. …//显示代码  
20.   
21. a=1;//错误，不能在const成员函数中修改普通变量  
22.   
23. showCount++;//正确  
24.   
25. }  

        const 承诺的是一旦某个变量被其修饰，那么只要不使用强制转换 （const_cast），在任何情况下该变量的值都不会被改变，无论有意还是无意，而被 const 修饰的函数也一样，一旦某个函数被 const 修饰，那么它便不能直接或间接改变任何函数体以外的变量的值，即使是调用一个可能造成这种改变的函数都不行。这种承诺在语法上也作出严格的保证，任何可能违反这种承诺的行为都会被编译器检查出来。

       mutable 的承诺是如果某个变量被其修饰，那么这个变量将永远处于可变的状态，即使在一个 const 函数中。这与 const 形成了一个对称的定义，一个永远不变，而另外一个是永远可变。

       看一个变量或函数是否应该是 const，只需看它是否应该是 constant 或 invariant，而看一个变量是否应该是 mutable，也只需看它是否是 forever mutative。

       这里出现了令人纠结的 3 个问题：

       1、为什么要保护类的成员变量不被修改？

       2、为什么用 const 保护了成员变量，还要再定义一个 mutable 关键字来突破 const 的封锁线？

       3、到底有没有必要使用 const 和 mutable 这两个关键字？

       保护类的成员变量不在成员函数中被修改，是为了保证模型的逻辑正确，通过用 const 关键字来避免在函数中错误的修改了类对象的状态。并且在所有使用该成员函数的地方都可以更准确的预测到使用该成员函数的带来的影响。而 mutable 则是为了能突破 const 的封锁线，让类的一些次要的或者是辅助性的成员变量随时可以被更改。没有使用 const 和 mutable 关键字当然没有错，const 和 mutable 关键字只是给了建模工具更多的设计约束和设计灵活性，而且程序员也可以把更多的逻辑检查问题交给编译器和建模工具去做，从而减轻程序员的负担。

     (2)volatile

       像 const 一样，volatile 是一个类型修饰符。volatile 修饰的数据,编译器不可对其进行执行期寄存于寄存器的优化。这种特性,是为了满足多线程同步、中断、硬件编程等特殊需要。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的直接访问。

       volatile 原意是“易变的”，但这种解释简直有点误导人，应该解释为 “直接存取原始内存地址” 比较合适。“易变” 是相对与普通变量而言其值存在编译器（优化功能）未知的改变情况（即不是通过执行代码赋值改变其值的情况），而是因外在因素引起的，如多线程，中断等。编译器进行优化时，它有时会取一些值的时候，直接从寄存器里进行存取，而不是从内存中获取，这种优化在单线程的程序中没有问题，但到了多线程程序中，由于多个线程是并发运行的，就有可能一个线程把某个公共的变量已经改变了，这时其余线程中寄存器的值已经过时，但这个线程本身还不知道，以为没有改变，仍从寄存器里获取，就导致程序运行会出现未定义的行为。并不是因为用 volatile 修饰了的变量就是“易变”了，假如没有外因，即使用 volatile 定义，它也不会变化。而加了 volatile 修饰的变量，编译器将不对其相关代码执行优化，而是生成对应代码直接存取原始内存地址。

       一般说来，volatile 用在如下的几个地方：

       1、中断服务程序中修改的供其它程序检测的变量需要加 volatile；

       2、多任务环境下各任务间共享的标志应该加 volatile；

       3、存储器映射的硬件寄存器通常也要加 volatile 说明，因为每次对它的读写都可能有不同意义；

       使用该关键字的例子如下：

[cpp]  view plain  copy

 print?

1. volatile int i=10;  
2.   
3. int a = i;  
4.   
5. …  
6.   
7. //其他代码，并未明确告诉编译器，对i进行过操作  
8.   
9. int b = i;  

        volatile 指出 i 是随时可能发生变化的，每次使用它的时候必须从i的地址中读取，因而编译器生成的汇编代码会重新从 i 的地址读取数据放在 b 中。而优化做法是，由于编译器发现两次从 i 读数据的代码之间的代码没有对 i 进行过操作，它会自动把上次读的数据（即10）放在 b 中，而不是重新从 i 里面读。这样以来，如果 i 是一个寄存器变量或者表示一个端口数据就容易出错，所以说 volatile 可以保证对特殊地址的直接访问。

[html]  view plain  copy

 print?

1. //addr为volatile变量  
2. addr=0x57;   
3. addr=0x58;  

       如果上述两条语句是对外部硬件执行不同的操作，那么编译器就不能像对待普通的程序那样对上述语句进行优化只认为 “addr=0x58;” 而忽略第一条语句（即只产生一条机器代码），此时编译器会逐一的进行编译并产生相应的机器代码（两条）。

       volatile 总是与优化有关，编译器有一种技术叫做数据流分析，分析程序中的变量在哪里赋值、在哪里使用、在哪里失效，分析结果可以用于常量合并，常量传播等优化，进一步可以死代码消除。但有时这些优化不是程序所需要的，这时可以用 volatile 关键字禁止做这些优化，它有下面的作用：
　　1、不会在两个操作之间把 volatile 变量缓存在寄存器中。在多任务、中断等环境下，变量可能被其他的程序改变，编译器自己无法知道，volatile 就是告诉编译器这种情况。
　　2、不做常量合并、常量传播等优化，所以像下面的代码，if的条件不会当作无条件真。 

[cpp]  view plain  copy

 print?

1. volatile int i = 1;   
2. 　　if (i > 0)  
3.        …   

       3、对 volatile 变量的读写不会被优化掉。如果你对一个变量赋值但后面没用到，编译器常常可以省略那个赋值操作，然而对 Memory Mapped IO 的处理是不能这样优化的。

【原文链接】

    [1] 《C/C++要点全掌握（五）——mutable、volatile》