Const 终于找到详解

   

我们也许学习过const的使用，但是对于const的细致的技术细节却不一定掌握。const的用法在许多的教材上只是简单的介绍，在这里我们对 const进行细致的概念以及用法剖析。const 是由c++采用，并加进标准c中，但是他们的意义完全不同，在旧版本(标准前)的c中，如果想建立一个常量，必须使用预处理器：
#define PI 3.14159

此后无论在何处使用PI，都会被预处理器以3.14159替代。编译器不对PI进行类型检查，也就是说可以不受限制的建立宏并用它来替代值，如果使用不慎，很可能由预处理引入错误，这些错误往往很难发现。

我们也不能得到PI的地址（即不能向PI传递指针和引用）。
c++引入了命名常量的概念，命名常量就像变量一样，只是它的值不能改变，如果试图改变一个const 对象，编译器将会产生错误。 const 和正常变量一样有作用域，所以函数内部的const也不会影响程序的其余部分。在c++中const可以取代预处理器#define来进行值替代， const有安全的类型检查，所以不用担心会像预处理器一样引入错误。

在通常的情况下const同预处理器#define一样只是将所赋值保存入编译器的符号表中（符号表仅仅在编译时存在，在编译过程中编译器将程序中 的名字与之在符号表中定义的数值作简单的替换），在使用的时候进行值替换，并不为const创建存储空间。我们将const的定义放进头文件里，这样通过 包含头文件，可以把const定义单独放在一个地方并把它分配给一个编译单元，const默认为内部连接（内部连接意味着只对正在编译的文件创建存储空 间，别的文件可以使用相同的标示符和全局变量，编译器不会发现冲突，外部连接意味着为所有被编译过的文件创建一片单独的存储空间，一般全局变量和函数名的 外部连接通过extern声明，可以通过其他的文件访问）也就是说const仅能被它所定义过的文件访问，在定义一个const时，必须赋一个值给它，除 非用extern做出说明：

extern const int a;

这表示const的定义在其他的什么地方，这里仅仅是一个声明，但是这样的做法使const使用了外部连接，也就是说上面的extern强制进行了 对const的存储空间分配，这样我们就无法再用const作为常量折叠（在可能的情况下，符号常量的值会代替改名字的出现，这个替代过程叫做常量折叠） 使用了，即使我们在其他地方定义了const的值,如：

extern const int a=3;

因为const的值被放入了存储单元，在编译的过程中，编译器不会去读存储单元的内容。如果我们这样做：

int b[a];

编译器就会给我们一个错误信息。

想不为const分配存储空间是不可能的，因为对于复杂的结构，例如集合，编译器不会复杂到将集合保存到它的符号表中，所以必须分配内存空间，这就意味着“这是一块不能改变的存储空间”，当然也就不能在编译期间使用它的值，因为编译器不知道存储的内容：

const int i[]={1,2,3,4};

//float f[i[2]];
//将得到错误信息，编译器提示不能在数组定义里找到一个常数表达式。

因为编译器靠移动栈指针来存储和读取数据。
也因此，由于无法避免为const分配内存，所以const的定义必须默认为内部连接，否则由于众多的const在多个文件中分配内存，就会引起错误。下面我们看一段简单有效的代码来说明const的常量折叠：

#include
const int a=3;
const int b=a+1;
float *f=(float*)&b;
char c[b+3];
void main()
{
const char gc=cin.get();
const char c2=gc+3;
}

我们可以看到，a是一个编译器期间的const，b是从a中计算出来的，由于a是一个const，b的计算值来自一个常数表达式，而它自身也是一个 编译器间的const，接着下面指针f取得了b的地址，所以迫使编译器给b分配了存储空间，不过即使分配了存储空间，由于编译器已经知道了b的值,所以仍 然不妨碍在决定数组c的大小时使用b。

在主函数main()里，标识符gc的值在编译期间是不知道的，这也意味着需要存储空间，但是初始化要在定义点进行，而且一旦初始化，其值就不能改 变，我们发现c2是由gc计算出来的，它的作用域与其他类型const的作用域是一样的，这是对#define用法的一种改进。

在c++引进常量的时候，标准c也引入了const，但是在c中const的意思和在c++中有很大不同，在c中const的意思是“一个不能改变的普通变量”，const常量总是被分配存储空间而且它的名字是全局符即const使用外部连接。于是在c中：

const int size=100;
char c[size];

得出一个错误。但是在c中可以这样写：

const int size;

因为c中的const被默认为外部连接，所以这样做是合理的。
在c语言中使用限定符const不是很有用，如果希望在常数表达式里（必须在编译期间被求值）使用一个已命名的值，必须使用预处理器#define。

在c++中可以使指针成为const，这很有用，如果以后想在程序代码中改变const这种指针的使用，编译器将给出通知，这样大大提高了安全性。在用带有const的指针时，我们有两种选择：const修饰指针指向的对象，或者const修饰指针自己指向的存储空间。

如果要使指向的对象不发生改变，则需要这样写：

const int *p;

这里p是一个指向const int 的指针，它不需要初始化，因为p可以指向任何标识符，它自己并不是一个const，但是它所指的值是不能改变的，同样的，我们可以这样写：

int const *p;

这两种方法是等同的，依据个人习惯以及编码风格不同，程序员自己决定使用哪一种形式。
如果希望使指针成为一个const必须将const标明的部分放在*右边。

int a=3;
int *const j=&a

编译器要求给它一个初始值，这个值在指针的生命期间内不变，也就是说指针始终指向a的地址，不过要改变它地址中的值是可以的：

*j+=4;

也可以是一个const指针指向一个const对象：

const int *j1=&a;
int const *j2=&a;

这样指针和对象都不能改变，这两种形式同样是等同的。在赋值的的时候需要注意，我们可以将一个非const的对象地址赋给一个const指针，但是 不能将一个const对象地址赋给一个非const指针，因为这样可能通过被赋值的指针改变对象的值，当然也可以用类型的强制转换来进行const对象的 赋值，但是这样做打破了const提供的安全性。

const也被用于限定函数参数和函数的返回值，如果函数参数是按值传递时，即表示变量的初值不会被函数改变，如果函数的返回值为const那么对 于内部类型来说按值返回的是否是一个cosnt是无关紧要的，编译器不让它成为一个左值，因为它是一个值而不是一个变量，所以使用const是多余的，例 如：

const int f(){return 1;}
void main(){int a=f();}

但是当处理用户定义类型的时候，按值返回常量就很有意义了，这时候函数的返回值不能被直接赋值也不能被修改。仅仅是非const返回值能作为一个左 值使用，但是这往往失去意义，因为函数返回值在使用时通常保存为一个临时量，临时量被作为左值使用并修改后，编译器将临时量清除。结果丢失了所有的修改。
可以用const限定传递或返回一个地址（即一个指针或一个引用）：

const int * const func(const int *p)
{ static int a=*p;
return &a;
}

参数内的const限定指针p指向的数据不能被改变，此后p的值被赋给静态变量a,然后将a的地址返回，这里a是一个静态变量，在函数运行结束后， 它的生命期并没有结束，所以可以将它的地址返回。因为函数返回一个const int* 型，所以函数func的返回值不可以赋给一个非指向const的指针，但它同时接受一个const int * const和一个const int *指针，这是因为在函数返回时产生一个const临时指针用以存放a的地址，所以自动产生了这种原始变量不能被改变的约定，于是*右边的const只有当 作左值使用时才有意义。

const同样运用于类中，但是它的意义又有所不同，我们可以创建const的数据成员，const的成员函数，甚至是const的对象，但是保持类的对象为const比较复杂，所以const对象只能调用const成员函数。

const的数据成员在类的每一个对象中分配存储，并且一旦初始化这个值在对象的生命期内是一个常量，因此在类中建立一个const数据成员时，初 始化工作必须在构造函数初始化列表中。如果我们希望创建一个有编译期间的常量成员，这就需要在该常量成员的前面使用static限定符，这样所有的对象都 仅有一个实例：

class X
{
static const int size=50;
int a[size];
public:
X();
};

const对象只能调用const成员函数，一个普通对象同样可以调用const成员函数，因此，const成员函数更具有一般性，但是成员函数不会默认为const。声明一个const成员函数，需要将const限定符放在函数名的后面：

void f (void ) const;

当我们运用const成员函数时，遇到需要改变数据成员，可以用mutable进行特别的指定：

class X
{
mutable int i;
public:
X();
void nochange() const;
};

void X::nochange const(){i++;}

const消除了预处理器的值替代的不良影响，并且提供了良好的类型检查形式和安全性，在可能的地方尽可能的使用const对我们的编程有很大的帮助。