C++的关键字volatile，mutable关键字，explicit关键字

volatile关键字

volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。声明时语法：int volatile vInt; 当要求使用 volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存

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

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

mutable关键字

mutalbe的中文意思是“可变的，易变的”，跟constant（既C++中的const）是反义词。
mutable 从字面意思上来说，是「可变的」之意。
显然，「可变的」只能用来形容变量，而不可能是「函数」或者「类」本身。然而，既然是「变量」，那么它本来就是可变的，也没有必要使用 mutable 来修饰。那么，mutable 就只能用来形容某种不变的东西了。
C++ 中，不可变的变量，称之为常量，使用 const 来修饰。然而，若是 const mutable 联用，未免让人摸不着头脑——到底是可变还是不可变呢？

事实上，mutable 是用来修饰一个 const 示例的部分可变的数据成员的。如果要说得更清晰一点，就是说 mutable 的出现，将 C++ 中的 const 的概念分成了两种。

二进制层面的 const，也就是「绝对的」常量，在任何情况下都不可修改（除非用 const_cast）。
引入 mutable 之后，C++ 可以有逻辑层面的 const，也就是对一个常量实例来说，从外部观察，它是常量而不可修改；但是内部可以有非常量的状态。
当然，所谓的「逻辑 const」，在 C++ 标准中并没有这一称呼。这只是为了方便理解，而创造出来的名词。
显而易见，mutable 只能用来修饰类的数据成员；而被 mutable 修饰的数据成员，可以在 const 成员函数中修改。
2、在C++中，mutable也是为了突破const的限制而设置的。被mutable修饰的变量，将永远处于可变的状态，即使在一个const函数中。
3、我们知道，被const关键字修饰的函数的一个重要作用就是为了能够保护类中的成员变量。即：该函数可以使用类中的所有成员变量，但是不能修改他们的值。
然而，在某些特殊情况下，我们还是需要在const函数中修改类的某些成员变量，因为要修改的成员变量与类本身并无多少关系，即使修改了也不会对类造成多少影响。当然，你可以说，你可以去掉该函数的const关键字啊！但问题是，我只想修改某个成员变量，其余成员变量仍然希望被const保护。

explicit关键字

首先, C++中的explicit关键字只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示的, 而非隐式的。
跟它相对应的另一个关键字是implicit, 意思是隐藏的,类构造函数默认情况下即声明为implicit(隐式)。

显示声明的构造函数和隐式声明的有什么区别呢? 我们来看下面的例子:

class CxString  // 没有使用explicit关键字的类声明, 即默认为隐式声明  
{  
public:  
	char *_pstr;  
	int _size;  
	CxString(int size)  
	{  
		_size = size;                // string的预设大小  
		_pstr = malloc(size + 1);    // 分配string的内存  
		memset(_pstr, 0, size + 1);  
	}  
	CxString(const char *p)  
	{  
		int size = strlen(p);  
		_pstr = malloc(size + 1);    // 分配string的内存  
		strcpy(_pstr, p);            // 复制字符串  
		_size = strlen(_pstr);  
	}  
	// 析构函数这里不讨论, 省略...  
};  

// 下面是调用:

CxString string1(24); // 这样是OK的, 为CxString预分配24字节的大小的内存 CxString
string2 = 10; // 这样是OK的, 为CxString预分配10字节的大小的内存 CxString string3;
// 这样是不行的, 因为没有默认构造函数, 错误为: “CxString”: 没有合适的默认构造函数可用 CxString
string4(“aaaa”); // 这样是OK的 CxString string5 = “bbb”; // 这样也是OK的,
调用的是CxString(const char *p) CxString string6 = ‘c’; // 这样也是OK的,
其实调用的是CxString(int size), 且size等于’c’的ascii码 string1 = 2;
// 这样也是OK的, 为CxString预分配2字节的大小的内存 string2 = 3; //
这样也是OK的, 为CxString预分配3字节的大小的内存 string3 = string1; // 这样也是OK的,
至少编译是没问题的, 但是如果析构函数里用free释放_pstr内存指针的时候可能会报错, 完整的代码必须重载运算符"=",
并在其中处理内存释放
上面的代码中, “CxString string2 = 10;” 这句为什么是可以的呢? 在C++中, 如果的构造函数只有一个参数时, 那么在编译的时候就会有一个缺省的转换操作:将该构造函数对应数据类型的数据转换为该类对象. 也就是说 “CxString string2 = 10;” 这段代码, 编译器自动将整型转换为CxString类对象, 实际上等同于下面的操作:

CxString string2(10);  
或  
CxString temp(10);  
CxString string2 = temp;  

但是, 上面的代码中的_size代表的是字符串内存分配的大小, 那么调用的第二句 “CxString string2 = 10;” 和第六句 “CxString string6 = ‘c’;” 就显得不伦不类, 而且容易让人疑惑. 有什么办法阻止这种用法呢? 答案就是使用explicit关键字. 我们把上面的代码修改一下, 如下:

class CxString  // 使用关键字explicit的类声明, 显示转换  
{  
public:  
	char *_pstr;  
	int _size;  
	explicit CxString(int size)  
	{  
		_size = size;  
		// 代码同上, 省略...  
	}  
	CxString(const char *p)  
	{  
		// 代码同上, 省略...  
	}  
};  

// 下面是调用:  

CxString string1(24);     // 这样是OK的  
CxString string2 = 10;    // 这样是不行的, 因为explicit关键字取消了隐式转换  
CxString string3;         // 这样是不行的, 因为没有默认构造函数  
CxString string4("aaaa"); // 这样是OK的  
CxString string5 = "bbb"; // 这样也是OK的, 调用的是CxString(const char *p)  
CxString string6 = 'c';   // 这样是不行的, 其实调用的是CxString(int size), 且size等于'c'的ascii码, 但explicit关键字取消了隐式转换  
string1 = 2;              // 这样也是不行的, 因为取消了隐式转换  
string2 = 3;              // 这样也是不行的, 因为取消了隐式转换  
string3 = string1;        // 这样也是不行的, 因为取消了隐式转换, 除非类实现操作符"="的重载  

explicit关键字的作用就是防止类构造函数的隐式自动转换.
上面也已经说过了, explicit关键字只对有一个参数的类构造函数有效, 如果类构造函数参数大于或等于两个时, 是不会产生隐式转换的, 所以explicit关键字也就无效了.