C/C++中const、mutable、volatile详解

const

     1、const修饰各种变量的用法.
    a、取代define
        #define D_INT 100
        #define D_LONG 100.29
        ………
        const int D_INT = 100;
        const D_INT = 100;        //如果定义的int类型,可省略int.
        const long D_LONG = 100.29;
        ………
        const int& a = 100;
        const替代define虽然增加分配空间,可它却保证了类型安全.
        在C标准中,const定义的数据相当于全局的,而C++中视声明的位置而定.
    b、修饰指针相关的变量
        以三组简单的定义示意：
        Group1:  
        int a = 0;   
        const int* b = &a;------------     [1]               
        int const *b = &a;------------     [2]                    
        const int* const b = &a;-----    [4]  
         
        Group2:
        const char *p = "const";--------------[1]
        char const *p = "const";--------------[2]  
        char* const p = "const";--------------[3]  
        const char * const p = "const";------[4]     
    
        Group3:
        int a=0;
        const int &b = a;---------------[1]
        int const &b = a;---------------[2]
        int & const b = a;--------------[3]     //--->修饰引用时,const被忽略
        const int & const b = a;-----[4]
      总结：
        1.如果const位于星号左侧,则const用来修饰指针所指向的变量, 即指针指向的为不可变的.
        2.如果const位于星号右侧,const就是修饰指针本身,即指针本身是不可变的.
          因此,[1]和[2]的情况相同,指针所指向内容不可变(const放在变量
          声明符的位置无关), 这种情况下不允许对内容进行更改,如不能*a = 3 ;
        3.[3]中指针本身是不可变的，而指针所指向的内容是可变的,这种情况下不能对指针本身进行更改操作,如a++是错误的
        4.[4]中指针本身和指向的内容均为常量
          注意示例:
          1.const int& reference = 1000;
          2.char* p = "const"
             char*& q ;
  
      2、const在函数环境下的各种应用
      常用法示例如下：
      const A&     _Fun(const     A& _in);     //修饰引用型传入参数
      // A     _Fun(const A& _in);
      //A& _Fun(const A& _in);
      //上面的两种,在函数内部有特殊的步骤,这里不详提了…..

      const     A*     _Fun( const     A* _in);      //修饰指针型传入参数
      void _Fun( ) const;      //修饰class成员函数
      const     A&     _Fun(A& _in );     //修饰返回值
      const A & operator(const A& _in);     //同时修饰传入参数和返回值

    a、修饰参数
        如void _Fun(const A* _in)或 void _Fun(const A& _in);它们被修饰后,在函数执行期间行为特性同于上面的讲解,注意：这不会改变原来数据的是否是const的属性.

    b、修饰函数返回值
       const A&     _Fun( )
       const A*      _Fun( );
       注意：由于生命期不同步的问题,不可将局部的变量的指针或引用返回(static除外).另外,传出来的视情况,代表不同的意思…对于A&返回类 型,你若将之赋与其它变量,那么它实际执行的是将返回的变量(或引用)代表的数据赋出..而你若将其它值赋予之,那么被赋予的是变量或引 用代表的数据. 而const A& 一般是防止之做为左值被赋值.

       这个地方还有很多的细节问题(譬如在连续赋值、返回的临时对象的处理、重载的const和非cosnt运算符等等),读者自己在实践中需要多多总结.

    3、修饰类成员函数的const.
      形如:void _Fun() const { };
      你需要知道的几点规则：

      a.const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.
      b.const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.
      c.const成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.
      e.然而加上mutable修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的const成员函数是可以修改它的…

    4、谈谈volatile和”完全const对象”
     一个有volatile修饰的类只允许访问其接口的一个子集，这个子集由类的 实现者来控制.用户只有用const_cast才可以访问这个类型的全部接口.而且,象const一样，类的volatile属性会传递给它的成员.想象 const修饰的对象,它的成员变量是不可修改的,而它通过指针维护的对象或原生变量是可修改.那么我们想:如果对象维护一个char* ,则它相当于char*    const chrptr ;而不是const char* cosnt chrptr;对于类中的指针你需要这样修饰以防止它或它维护的资源：cosnt x* xptr;而不是x*const xptr; 因为cosnt 修饰的对象它默认 的行为是延续变量：x* cosnt xptr; 更重要的,volatile修饰的数据,编译器不可对其进行执行期寄存于寄存器的优化.这种特性,是为了多线程同步的需要.有兴趣者看参看Andrei的 GP系列文章.

   5、谈谈const_cast转换运算符
     这个关键字最基础的用法是：去掉数据的const性质.
     值得注意的是：它只对指针、引用和其它的具有指向性质的类型.

mutable
mutable只能由于修饰类的非静态数据成员，对于使用使用mutable修饰的成员变量，const成员函数可以改变其值，比如下面的代码：
class X{
public:
     void foo() const
     {
        if (!changed_){
          changed_ = true;
        }
        // do something
     }
private:
     mutable bool changed_;
};
如果缺少mutable，那么就无法编译通过啦。
mutable具有欺骗性，使用它，可以使const的成员函数悄悄的改变的类的成员函数，而无须使用const_cast来转换this指针。
  
mutable和const
       声明：这里讨论的const是用来修饰函数的const，而不是用来修饰变量的const。虽然是同一个关键字，但yayv还是觉得把他们当作2个关键字来理解更好一些。
       C++中const关键字用来表示一个常量，同时const也用来修饰函数。yayv在这个要明确的概念是：const所修饰的函数只能是类的成员函数， 因为const所修饰的函数中，要由编译器负责保护类的成员变量不被修改。而相对的，mutable则是用来修饰类的成员变量，让该变量在const所修 饰的成员函数中可以被修改。而且const修饰的函数只能是类的成员函数，mutable修饰的变量只能是类的成员变量。简直就是一对冤家对头~
这里出现了3个问题：
第一：为什么要保护类的成员变量不被修改
第二：为什么用const保护了成员变量，还要再定义一个mutable关键字来突破const的封锁线？
第三：到底有没有必要使用const 和 mutable这两个关键字？
       yayv对这三个问题的看法是：
       保护类的成员变量不在成员函数中被修改，是为了保证模型的逻辑正确，通过用const关键字来避免在函数中错误的修改了类对象的状态。并且在所有使用该成员函数的地方都可以更准确的预测到使用该成员函数的带来的影响。
       而mutable则是为了能突破const的封锁线，让类的一些次要的或者是辅助性的成员变量随时可以被更改。
       没有使用const和mutable关键字当然没有错，const和mutable关键字只是给了建模工具更多的设计约束和设计灵活性，而且程序员也可以 把更多的逻辑检查问题交给编译器和建模工具去做，从而减轻程序员的负担(yayv觉得这只不过是把负担移交给了设计人员~, :（，并没有降低任何工作量 )。
      如果开发过程有比较严格的迭代过程，使用这两个关键字应该更能体现出他们的作用。

volatile
在Andrei Alexandrescu的文章《volatile - Multithreaded Programmer's Best Friend》[2]开头有如下简要描述：
The volatile keyword was devised to prevent compiler optimizations that might render code incorrect in the presence of certain asynchronous events. For example, if you declare a primitive variable as volatile, the compiler is not permitted to cache it in a register -- a common optimization that would be disastrous if that variable were shared among multiple threads. So the general rule is, if you have variables of primitive type that must be shared among multiple threads, declare those variables volatile. But you can actually do a lot more with this keyword: you can use it to catch code that is not thread safe, and you can do so at compile time. This article shows how it is done; the solution involves a simple smart pointer that also makes it easy to serialize critical sections of code.
volatile修饰的变量防止被优化，主要用在多线程程序中。避免编译器优化。编译器进行优化时，它有时会取一些值的时候，直接从寄存器里进行存取，而 不是从内存中获取，这种优化在单线程的程序中没有问题，但到了多线程程序中，由于多个线程是并发运行的，就有可能一个线程把某个公共的变量已经改变了，这 时其余线程中寄存器的值已经过时，但这个线程本身还不知道，以为没有改变，仍从寄存器里获取，就导致程序运行会出现未定义的行为。  

存储易变

volatile的本意是“易变的”    ，由于访问寄存器的速度要快过RAM，所以编译器一般都会作减少存取外部RAM的优化。比如：

static int i=0;

int main(void)
{
...
while (1)
{
if (i) dosomething();
}
}

/* Interrupt service routine. */
void ISR_2(void)
{
i=1;
}

程序的本意是希望ISR_2中断产生时，在main当中调用dosomething函数，但是，由于编译器判断在main函数里面没有修改过i，因此可能 只执行一次对从i到某寄存器的读操作，然后每次if判断都只使用这个寄存器里面的“i副本”，导致dosomething永远也不会被调用。如果将将变量 加上volatile修饰，则编译器保证对此变量的读写操作都不会被优化（肯定执行）。此例中i也应该如此说明。

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

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

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

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

另外，以上这几种情况经常还要同时考虑数据的完整性（相互关联的几个标志读了一半被打断了重写），在1中可以通过关中断来实现，2中可以禁止任务调度，3中则只能依靠硬件的良好设计了。

补充说明

         volatile应该解释为“直接存取原始内存地址”比较合适，“易变的”这种解释简直有点误导人；“易变”是因为外在因素引起的，象多线程，中断等，并 不是因为用volatile修饰了的变量就是“易变”了，假如没有外因，即使用volatile定义，它也不会变化；而用volatile定义之后，其实 这个变量就不会因外因而变化了，可以放心使用了；volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。使用该关键字的例子如下：

int volatile nVint;
当要求使用volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。

例如：

volatile int i=10;
int a = i;
...
//其他代码，并未明确告诉编译器，对i进行过操作
int b = i;

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

关键字volatile有什么含意，并给出三个不同的例子
一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：
       1). 并行设备的硬件寄存器（如：状态寄存器）
       2). 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
       3). 多线程应用中被几个任务共享的变量
       回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。嵌入式系统程序员经常同硬件、中断、RTOS等等打交道，所用这些都要求volatile变量。不懂得volatile内容将会带来灾难。
       假设被面试者正确地回答了这是问题（嗯，怀疑这否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。
       1). 一个参数既可以是const还可以是volatile吗？解释为什么。
       2). 一个指针可以是volatile 吗？解释为什么。
       3). 下面的函数有什么错误：
            int square(volatile int *ptr)
            {
                 return *ptr * *ptr;
            }
       下面是答案：
       1). 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
       2). 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
       3). 这段代码的有个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：
       int square(volatile int *ptr)
       {
            int a,b;
            a = *ptr;
            b = *ptr;
            return a * b;
        }
       由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：
        long square(volatile int *ptr)
        {
               int a;
               a = *ptr;
               return a * a;
        }