C++基本功：全面掌握const、volatile和mutable关键字
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]中指针本身和指向的内容均为常量.(引用特殊：引用在使用增加
遇义时,增加它代表的变量.所以qualifiers on reference are ignoredv.
延伸点:
注意示例:
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运算符等等),读者自己在实践中需要多多总结.
使用可变（mutable）成员隐藏实现细节
作者： Builder.com
键字 mutable 是一个奇怪的修饰符（specifier），它只能够用于一个类的非静态数据成员。下面我将讨论 mutable 的语义和用法，但是首先我要解释一下 C++ 对象模型的一个关键概念。
键字 mutable 是一个奇怪的修饰符（specifier），它只能够用于一个类的非静态数据成员。下面我将讨论 mutable 的语义和用法，但是首先我要解释一下 C++ 对象模型的一个关键概念。
对象的状态
一个对象的状态由其非静态数据成员的值构成，因此，修改一个数据成员将会改变整个对象的状态。将一个成员函数声明为 const 能够保证它不会改变对象的状态。
然而在一些情况下，对象的逻辑状态与基物理状态之间可能有差别。例如，对于一个表示绘画图像的对象就存在这种情况。如果图像还没有更改，那么我们就认为其状态没有发生变化。然而，从底层实现方面来说，如果大对象在一段时间没有活动，那么它们的内存通常会被交换到一个文件中。交换一个图像并不会真地影响其状态，但是对象的一些数据成员可能会发生变化，在这里可能会发生变化的是指针、标志位等。
在用户调用一个诸如 Redraw() 之类的 const 成员函数时，他们并不关心这个函数在内部是如何实现的。从他们的角度来说，这个函数并不改变对象的逻辑状态，因此被声明为 const。Redraw() 有可能修改对象的物理状态这一事实是一个他们不应该关心的实现细节。例如：
int Image::Redraw() const
{
if (isLoaded==false)
{
//..read image data from a disk into a local buffer
isLoaded=true; //changing a data member's value
}
//..paint image in the screen
}
class Image
可变（mutable）数据成员
如果尝试编译这段代码，你会得到一个编译错误。虽然 Redraw() 声明为 const，但是它修改了一个数据成员。解决这个编译错误的方法是将 isLoaded 声明为一个 mutable 数据成员：
class Image
{
public:
int Redraw() const;
//..
private:
mutable bool isLoaded;//can be changed by a const function
};
不像普通的数据成员，const 成员函数可以修改 mutable 数据成员。
Mutable 数据成员的使用看上去像是骗术，因为它能够使 const 函数修改对象的数据成员。然而，明智地使用 mutable 关键字可以提高代码质量，因为它能够让你向用户隐藏实现细节，而无须使用不确定的东西，比如 const_cast<>。
对象的状态
一个对象的状态由其非静态数据成员的值构成，因此，修改一个数据成员将会改变整个对象的状态。将一个成员函数声明为 const 能够保证它不会改变对象的状态。
然而在一些情况下，对象的逻辑状态与基物理状态之间可能有差别。例如，对于一个表示绘画图像的对象就存在这种情况。如果图像还没有更改，那么我们就认为其状态没有发生变化。然而，从底层实现方面来说，如果大对象在一段时间没有活动，那么它们的内存通常会被交换到一个文件中。交换一个图像并不会真地影响其状态，但是对象的一些数据成员可能会发生变化，在这里可能会发生变化的是指针、标志位等。
在用户调用一个诸如 Redraw() 之类的 const 成员函数时，他们并不关心这个函数在内部是如何实现的。从他们的角度来说，这个函数并不改变对象的逻辑状态，因此被声明为 const。Redraw() 有可能修改对象的物理状态这一事实是一个他们不应该关心的实现细节。例如：
int Image::Redraw() const
{
if (isLoaded==false)
{
//..read image data from a disk into a local buffer
isLoaded=true; //changing a data member's value
}
//..paint image in the screen
}
class Image
可变（mutable）数据成员
如果尝试编译这段代码，你会得到一个编译错误。虽然 Redraw() 声明为 const，但是它修改了一个数据成员。解决这个编译错误的方法是将 isLoaded 声明为一个 mutable 数据成员：
class Image
{
public:
int Redraw() const;
//..
private:
mutable bool isLoaded;//can be changed by a const function
};
不像普通的数据成员，const 成员函数可以修改 mutable 数据成员。
Mutable 数据成员的使用看上去像是骗术，因为它能够使 const 函数修改对象的数据成员。然而，明智地使用 mutable 关键字可以提高代码质量，因为它能够让你向用户隐藏实现细节，而无须使用不确定的东西，比如 const_cast<>。
volatile关键字
volatile是c/c++中一个鲜为人知的关键字,该关键字告诉编译器不要持有变量的临时拷贝,它可以适用于基础类型
如：int,char,long......也适用于C的结构和C++的类。当对结构或者类对象使用volatile修饰的时候，结构或者
类的所有成员都会被视为volatile.
使用volatile并不会否定对CRITICAL_SECTION,Mutex,Event等同步对象的需要
例如：
int i;
i = i + 3;
无论如何，总是会有一小段时间，i会被放在一个寄存器中，因为算术运算只能在寄存器中进行。一般来说，volatitle
关键字适用于行与行之间，而不是放在行内。
我们先来实现一个简单的函数，来观察一下由编译器产生出来的汇编代码中的不足之处，并观察volatile关键字如何修正
这个不足之处。在这个函数体内存在一个busy loop(所谓busy loop也叫做busy waits,是一种高度浪费CPU时间的循环方法)
oid getKey(char* pch)
{
while (*pch == 0)
;
}
当你在VC开发环境中将最优化选项都关闭之后，编译这个程序，将获得以下结果(汇编代码)
; while (*pch == 0)
$L27
; Load the address stored in pch
mov eax, DWORD PTR _pch$[ebp]
; Load the character into the EAX register
movsx eax, BYTE PTR [eax]
; Compare the value to zero
test eax, eax
; If not zero, exit loop
jne $L28
;
jmp $L27
$L28
;}
这段没有优化的代码不断的载入适当的地址，载入地址中的内容，测试结果。效率相当的低，但是结果非常准确
现在我们再来看看将编译器的所有最优化选项开关都打开以后，重新编译程序，生成的汇编代码，和上面的代码
比较一下有什么不同
;{
; Load the address stored in pch
mov eax, DWORD PTR _pch$[esp-4]
; Load the character into the AL register
movsx al, BYTE PTR [eax]
; while (*pch == 0)
; Compare the value in the AL register to zero
test al, al
; If still zero, try again
je SHORT $L84
;
;}
使用可变（mutable）成员隐藏实现细节
作者： Builder.com
键字 mutable 是一个奇怪的修饰符（specifier），它只能够用于一个类的非静态数据成员。下面我将讨论 mutable 的语义和用法，但是首先我要解释一下 C++ 对象模型的一个关键概念。
键字 mutable 是一个奇怪的修饰符（specifier），它只能够用于一个类的非静态数据成员。下面我将讨论 mutable 的语义和用法，但是首先我要解释一下 C++ 对象模型的一个关键概念。
对象的状态
一个对象的状态由其非静态数据成员的值构成，因此，修改一个数据成员将会改变整个对象的状态。将一个成员函数声明为 const 能够保证它不会改变对象的状态。
然而在一些情况下，对象的逻辑状态与基物理状态之间可能有差别。例如，对于一个表示绘画图像的对象就存在这种情况。如果图像还没有更改，那么我们就认为其状态没有发生变化。然而，从底层实现方面来说，如果大对象在一段时间没有活动，那么它们的内存通常会被交换到一个文件中。交换一个图像并不会真地影响其状态，但是对象的一些数据成员可能会发生变化，在这里可能会发生变化的是指针、标志位等。
在用户调用一个诸如 Redraw() 之类的 const 成员函数时，他们并不关心这个函数在内部是如何实现的。从他们的角度来说，这个函数并不改变对象的逻辑状态，因此被声明为 const。Redraw() 有可能修改对象的物理状态这一事实是一个他们不应该关心的实现细节。例如：
int Image::Redraw() const
{
if (isLoaded==false)
{
//..read image data from a disk into a local buffer
isLoaded=true; //changing a data member's value
}
//..paint image in the screen
}
class Image
可变（mutable）数据成员
如果尝试编译这段代码，你会得到一个编译错误。虽然 Redraw() 声明为 const，但是它修改了一个数据成员。解决这个编译错误的方法是将 isLoaded 声明为一个 mutable 数据成员：
class Image
{
public:
int Redraw() const;
//..
private:
mutable bool isLoaded;//can be changed by a const function
};
不像普通的数据成员，const 成员函数可以修改 mutable 数据成员。
Mutable 数据成员的使用看上去像是骗术，因为它能够使 const 函数修改对象的数据成员。然而，明智地使用 mutable 关键字可以提高代码质量，因为它能够让你向用户隐藏实现细节，而无须使用不确定的东西，比如 const_cast<>。
对象的状态
一个对象的状态由其非静态数据成员的值构成，因此，修改一个数据成员将会改变整个对象的状态。将一个成员函数声明为 const 能够保证它不会改变对象的状态。
然而在一些情况下，对象的逻辑状态与基物理状态之间可能有差别。例如，对于一个表示绘画图像的对象就存在这种情况。如果图像还没有更改，那么我们就认为其状态没有发生变化。然而，从底层实现方面来说，如果大对象在一段时间没有活动，那么它们的内存通常会被交换到一个文件中。交换一个图像并不会真地影响其状态，但是对象的一些数据成员可能会发生变化，在这里可能会发生变化的是指针、标志位等。
在用户调用一个诸如 Redraw() 之类的 const 成员函数时，他们并不关心这个函数在内部是如何实现的。从他们的角度来说，这个函数并不改变对象的逻辑状态，因此被声明为 const。Redraw() 有可能修改对象的物理状态这一事实是一个他们不应该关心的实现细节。例如：
int Image::Redraw() const
{
if (isLoaded==false)
{
//..read image data from a disk into a local buffer
isLoaded=true; //changing a data member's value
}
//..paint image in the screen
}
class Image
可变（mutable）数据成员
如果尝试编译这段代码，你会得到一个编译错误。虽然 Redraw() 声明为 const，但是它修改了一个数据成员。解决这个编译错误的方法是将 isLoaded 声明为一个 mutable 数据成员：
class Image
{
public:
int Redraw() const;
//..
private:
mutable bool isLoaded;//can be changed by a const function
};
不像普通的数据成员，const 成员函数可以修改 mutable 数据成员。
Mutable 数据成员的使用看上去像是骗术，因为它能够使 const 函数修改对象的数据成员。然而，明智地使用 mutable 关键字可以提高代码质量，因为它能够让你向用户隐藏实现细节，而无须使用不确定的东西，比如 const_cast<>。
volatile关键字
volatile是c/c++中一个鲜为人知的关键字,该关键字告诉编译器不要持有变量的临时拷贝,它可以适用于基础类型
如：int,char,long......也适用于C的结构和C++的类。当对结构或者类对象使用volatile修饰的时候，结构或者
类的所有成员都会被视为volatile.
使用volatile并不会否定对CRITICAL_SECTION,Mutex,Event等同步对象的需要
例如：
int i;
i = i + 3;
无论如何，总是会有一小段时间，i会被放在一个寄存器中，因为算术运算只能在寄存器中进行。一般来说，volatitle
关键字适用于行与行之间，而不是放在行内。
我们先来实现一个简单的函数，来观察一下由编译器产生出来的汇编代码中的不足之处，并观察volatile关键字如何修正
这个不足之处。在这个函数体内存在一个busy loop(所谓busy loop也叫做busy waits,是一种高度浪费CPU时间的循环方法)
oid getKey(char* pch)
{
while (*pch == 0)
;
}
当你在VC开发环境中将最优化选项都关闭之后，编译这个程序，将获得以下结果(汇编代码)
; while (*pch == 0)
$L27
; Load the address stored in pch
mov eax, DWORD PTR _pch$[ebp]
; Load the character into the EAX register
movsx eax, BYTE PTR [eax]
; Compare the value to zero
test eax, eax
; If not zero, exit loop
jne $L28
;
jmp $L27
$L28
;}
这段没有优化的代码不断的载入适当的地址，载入地址中的内容，测试结果。效率相当的低，但是结果非常准确
现在我们再来看看将编译器的所有最优化选项开关都打开以后，重新编译程序，生成的汇编代码，和上面的代码
比较一下有什么不同
;{
; Load the address stored in pch
mov eax, DWORD PTR _pch$[esp-4]
; Load the character into the AL register
movsx al, BYTE PTR [eax]
; while (*pch == 0)
; Compare the value in the AL register to zero
test al, al
; If still zero, try again
je SHORT $L84
;
;}