本文共 9482 字，大约阅读时间需要 31 分钟。
const是一个C++语言的限定符，它限定一个变量不允许被改变。
用const修饰的变量是不可变的，以下两种定义形式在本质上是一样的：
const int a = 10;int const a = 10;
如果const位于*的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于*的右侧，const就是修饰指针本身，即指针本身是常量。
int a = 10;const int* p = &a; // 指针指向的内容不能变int const* p = &a; // 同上int* const p = &a; // 指针本身不能变const int* const p = &a; // 两者都不能变int const* const p = &a; // 同上
以下两种定义形式在本质上是一样的：
int a = 10;const int& b = a;int const& b = a;
用const修饰函数参数，传递过来的参数在函数内不可以改变。
void func (const int& n) { n = 10; // 编译错误} 用const修饰函数返回值的含义和用const修饰普通变量以及指针的含义基本相同。
const int* func() { // 返回的指针所指向的内容不能修改 // return p;} 用const修饰的类成员变量，只能在类的构造函数初始化列表中赋值，不能在类构造函数体内赋值。
class A {public： A(int x) : a(x) { // 正确 //a = x; // 错误 }private： const int a;}; 用const修饰的类成员函数，在该函数体内不能改变该类对象的任何成员变量, 也不能调用类中任何非const成员函数。
class A {public: int& getValue() const { // a = 10; // 错误 return a; }private: int a; // 非const成员变量}; 用const修饰的类对象，该对象内的任何成员变量都不能被修改。
因此不能调用该对象的任何非const成员函数，因为对非const成员函数的调用会有修改成员变量的企图。class A { public: void funcA() {} void funcB() const {}};int main { const A a; a.funcB(); // 可以 a.funcA(); // 错误 const A* b = new A(); b->funcB(); // 可以 b->funcA(); // 错误} class A {public: void func() {} void func() const {} // 重载}; 换句话说，宏是字符常量，在预编译完宏替换完成后，该宏名字会消失，所有对宏的引用已经全部被替换为它所对应的值，编译器当然没有必要再维护这个符号。而常量折叠发生的情况是，对const常量的引用全部替换为该常量的值，但是，常量并不会消失，编译器会将其放入到符号表中，同时，会为该常量分配空间。
#includeusing namespace std;int main() {#define DATA 1 const int Data = 2; int a = DATA; int b = Data; return 0;#undef DATA}
在下面的汇编代码可以看到，#define宏与const常量在汇编中都被替换成立即数，与代码一起存于代码区。
(gdb) disassemble /m mainDump of assembler code for function main():4 int main() { 0x00401460 <+0>: push %ebp 0x00401461 <+1>: mov %esp,%ebp 0x00401463 <+3>: and $0xfffffff0,%esp 0x00401466 <+6>: sub $0x10,%esp 0x00401469 <+9>: call 0x401a20 <__main>5 #define DATA 16 const int Data = 2;=> 0x0040146e <+14>: movl $0x2,0xc(%esp)7 int a = DATA; 0x00401476 <+22>: movl $0x1,0x8(%esp)8 int b = Data; 0x0040147e <+30>: movl $0x2,0x4(%esp)9 return 0; 0x00401486 <+38>: mov $0x0,%eax10 #undef DATA11 } 0x0040148b <+43>: leave 0x0040148c <+44>: retEnd of assembler dump. 在C++中，编译器会对内置整型数据类型的const常量进行常量替换，而在C中，则编译器没有做这部分优化，每次都要在const常量所在内存进行读取。
int main(){ const int a = 1; int b = a; return 0;} C版本汇编代码：
(gdb) disassemble /m mainDump of assembler code for function main:6 int main(){ 0x00401460 <+0>: push %ebp 0x00401461 <+1>: mov %esp,%ebp 0x00401463 <+3>: and $0xfffffff0,%esp 0x00401466 <+6>: sub $0x10,%esp 0x00401469 <+9>: call 0x4019a0 <__main>7 const int a = 1;=> 0x0040146e <+14>: movl $0x1,0xc(%esp)8 int b = a; 0x00401476 <+22>: mov 0xc(%esp),%eax 0x0040147a <+26>: mov %eax,0x8(%esp)9 return 0; 0x0040147e <+30>: mov $0x0,%eax10 } 0x00401483 <+35>: leave 0x00401484 <+36>: retEnd of assembler dump. C++版本汇编代码：
(gdb) disassemble /m mainDump of assembler code for function main():1 int main(){ 0x00401460 <+0>: push %ebp 0x00401461 <+1>: mov %esp,%ebp 0x00401463 <+3>: and $0xfffffff0,%esp 0x00401466 <+6>: sub $0x10,%esp 0x00401469 <+9>: call 0x4019a0 <__main>2 const int a = 1;=> 0x0040146e <+14>: movl $0x1,0xc(%esp)3 int b = a; 0x00401476 <+22>: movl $0x1,0x8(%esp)4 return 0; 0x0040147e <+30>: mov $0x0,%eax5 } 0x00401483 <+35>: leave 0x00401484 <+36>: retEnd of assembler dump. typedef关键字
通过typedef关键字可以给指针类型定义别名，当通过该别名定义const常量时等价于<数据类型> * const <变量名>=<初始值>
#includeusing namespace std;int main() { typedef int * A; int a = 1; const A pa = &a;// *(pa++); // 错误 (*pa)++; return 0;}
volatile关键字
volatile关键字是一种类型修饰符，用它声明的类型变量表示可能被某些编译器未知的因素更改，比如操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。
当要求使用volatile声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。
在下面代码中，const常量b通过volatile声明后，编译器不会对其进行常量替换，每次访问b，都从它所在的内存读取，所以通过指针改变b所在内存的数据，const常量b也会发生改变。
#includeusing namespace std;int main() { const int a = 1; volatile const int b = 2; int *pa = (int *)&a; int *pb = (int *)&b; cout< <<" "<<*pa<<"|"<<<" "<<*pb<
运行结果：
1 1|2 21 2|3 3
mutable关键字
在C++中，mutable关键字也是为了突破const的限制而设置的。被mutable修饰的变量（mutable只能由于修饰类的非静态数据成员），将永远处于可变的状态，即使在一个const函数中或者类的实例为const常量。