10.2　const修饰符

const在C语言中算是一个比较新的描述符，我们称之为常量修饰符，就是说，其所修饰的对象为常量。如果想要设法阻止一个变量被改变，那么可以选择使用const关键字。在为一个变量加上const修饰符的同时，通常需要对它进行初始化，在之后的程序中就不能再去改变它。

可能有的读者会有疑问，在C语言中不是有预处理指令“#define VariableName VariableValue”可以很方便地进行值替代吗，为什么还要引入const修饰符呢？这是因为预处理语句虽然可以很方便地进行值的替代，但是它有个比较致命的缺点，即预处理语句只是进行简单值替代，缺乏类型检测机制，这样，预处理语句就不具备C编译器严格类型检查的优点，因此它的使用存在着一系列的隐患和局限性。

在讲解const修饰符之前，首先说明const修饰符的几个典型作用。

const类型定义：指明变量或对象的值是不能被更新的，引入目的是为了取代预编译指令。

可以保护被修饰的内容，防止其被意外地修改，增强程序的健壮性。

编译器通常不为普通const常量分配存储空间，而是将它保存在符号表中，这使它成为一个编译期间的常量，没有了存储与读内存的操作，它的效率也很高。

可以节省空间，避免不必要的内存分配。

接下来介绍const修饰符的几种使用方式。

1.const修饰符在函数体内修饰局部变量

const int n=5；

和

int const n=5；

是等价的。在编程的过程中一定要清楚地知道const修饰的对象是谁，在这里修饰的是n，和int没有关系。const要求它所修饰的对象为常量，不能被改变，同时也不能够被赋值，所以下面这样的写法是错误的。

const int n；

n=0；

上面的情况是比较容易理解的，但是当const与指针一起使用时，就容易让人迷惑。例如，下面是关于p和q的声明：

const int*p；

int const*q；

看了上面的代码，有人可能会觉得“const intp；”表示的是const int类型的指针（const直接修饰int），而“int constq；”表示的是int类型的const指针（const直接修饰指针）。实际上，在上面的声明中，p和q都被声明为const int类型的指针。而声明int类型的const指针应该这样：

int*const r=＆n；

以上的p和q都是指向const int类型的指针，也就是说，在以后的程序中不能改变p的值。而r是一个const指针，在声明的时候将它初始化为指向变量n（即“r=＆n；”）之后，r的值将不允许再改变，但r的值是可以改变的。在此，为了判断const的修饰对象，介绍一种常用的方法：以为界线，如果const位于的左侧，那么const就是用来修饰指针所指向的变量的，即指针指向常量；如果const位于*的右侧，那么const就是修饰指针本身的，即指针本身是常量。接下来看下面的代码。

include＜stdio.h＞

int main（int argc,char*argv[]）

{

int ss=9；

int*const r=＆ss；

printf（"r=%d\n"，r）；

printf（"ss=%d\n"，ss）；

*r=100；

printf（"r=%d\n"，r）；

printf（"ss=%d\n"，ss）；

return 0；

}

运行结果：

*r=9

ss=9

*r=100

ss=100

简单分析一下，因为r指向的是ss的地址，所以修改r指向的地址单元的值的同时，ss的值也随之变化。

结合上述两种const修饰的情况，声明一个指向const int类型的const指针，如下：

const int*const r=＆ss；

这时，既不能修改*r的值，也不能修改r的值。

接下来看const用于修饰常量静态字符串的情况，例如：

const char*str="fdsafdsa"；

如果没有const的修饰，我们可以在后面写“str[4]='x'”这样的语句，这样会导致对只读内存区域赋值，然后程序会立刻异常终止。有了const，这个错误就能在程序被编译的时候立即检查出来，这就是const的好处，让逻辑错误在编译期被发现。

2.const在函数声明时修饰参数

voidmemmove（voiddest,const void*src,size_t count）；

这是标准库中的一个函数，在头文件#include＜string.h＞中声明，其功能为由src所指内存区域复制count个字节到dest所指向的内存区域，用于按字节方式复制字符串（内存）。它的第一个参数dest是表明将字符串复制到哪里去，即目的地，这段内存区域必须是可写的。它的第二个参数是要被复制的字符串，我们对这段内存区域仅进行只读操作，不进行写操作。于是，从这个函数自身的角度来看，src指针所指向的内存所存储的数据在整个函数执行的过程中是不变的，因此src所指向的内容是常量，于是就需要用const修饰。另外需要强调的一点就是，src和dest所指内存区域是可以重叠的，但是复制后，dest的内容会更改，函数返回指向dest的指针。看看下面的代码。

include＜stdio.h＞

include＜string.h＞

int main（int argc,char*argv[]）

{

const char*str="hello"；

char buf[10]；

memmove（buf,str，6）；

printf（"%s\n"，buf）；

return 0；

}

运行结果：

hello

如果反过来写成“memmove（str,buf，6）；”，那么编译器一定会报错。事实上，我们经常会把各种函数的参数顺序写反，此时编译器就帮了大忙。如果编译器不报错，即在函数声明“voidmemmove（voiddest,const void*src,size_t count）；”处去掉const，那么这个程序在运行的时候一定会崩溃。这里还要说明的一点是，在函数参数声明中，const一般用来声明指针而不是变量本身。例如，memmove函数中的参数size_t len在memmove函数实现的时候可以完全不用更改len的值，那么是否应该把len也声明为常量呢？可以这么做。现在来分析这么做有什么优劣。如果加了const，那么对于这个函数的实现者，可以防止他在实现这个函数的时候修改不需要修改的值（len），这样很好。但是对于这个函数的使用者来说，这样做有如下两个缺点：

修饰符号毫无意义，可以传递一个常量整数或者一个非常量整数，反正对方获得的只是传递的一个副本。

如果函数内部需要更改这个值，那么这样的声明在使用中会出现错误，而在实际使用中我们不需要知道实现这个函数时是否修改过len的值。

所以，对于参数的传递，const一般只用来修饰指针。再看一个复杂的例子：

int execv（const charpath,charconst argv[]）；

着重看argv代表什么。如果去掉const，由“charargv[]”可以看出，argv是一个数组，它的每个元素都是char类型的指针。如果加上const，那么const修饰的是谁呢？它修饰的是一个数组，argv[]表明这个数组的元素是只读的。那么数组的元素是什么类型呢？是char*类型的指针，也就是说，指针是常量，它所指向的地址是不能改变的，而地址中的内容是可以改变的，例如：

argv[1]=NULL；//非法

argv[0][0]='a'；//合法

3.const作为全局变量

在编写程序的过程中，要尽可能少地使用全局变量。因为全局变量的作用域是全局，其值在程序范围内都可以修改，从而导致了全局变量不能保证值的正确性，如果出现错误，会非常难以发现。如果在多线程中使用全局变量，那么程序将会出现很多未知的错误。多线程中一个线程可能会修改另一个线程使用的全局变量的值，如果不注意，那么一旦出错，后果不堪设想。我们要尽可能多地使用const，如果一个全局变量只在本文件中使用，那么其用法和前面所介绍的函数局部变量没有什么区别。如果它要在多个文件间共享，那么就牵扯到一个存储类型的问题，主要有以下两种声明方式。

（1）使用extern修饰

例如：

/pi.h/

extern const double pi；

/pi.c/

const double pi=3.14；

编写好上面的源文件和头文件之后，如果在编程中需要使用变量pi，只需要包含头文件pi.h即可。

include“pi.h”

或者把头文件中的那句声明在需要使用的源文件中重写一遍。这样做的结果是，整个程序链接完后，所有需要使用变量pi的共享一个存储区域。

（2）使用static修饰（静态外部存储类）

/constant.h/

static const double pi=3.14；

在需要使用这个变量的.c文件中，必须包含这个头文件。前面的static一定不能少，否则链接的时候会警告该变量被多次定义。这样做的结果是，每个包含了constant.h的.c文件都有一份该变量的副本，该变量实际上还是被定义了多次，占用了多个存储空间，不过加了关键字static后，解决了文件间重定义的冲突。使用静态外部存储类的坏处是浪费了存储空间，导致链接完后的可执行文件变大。通常，在存储空间字节的变化不是太大的情况下，不是问题。好处是不用关心这个变量是在哪个文件中被初始化的。看看下面的代码。

include＜stdio.h＞

int main（）

{

const int a=12；

const int*p=＆a；//这个是指向常量的指针，指针指向一个常量

p++；//指针可以自加、自减

p—；//合法

int constq=＆a；//这个和上面的“const intp=＆a；”是一个意思

int b=12；

int*const r=＆b；//这个就是常量指针（常指针），不能自加、自减，并且要初始化

//r++；//编译出错

const int*const t=＆b；//这个就是指向常量的常指针，并且要初始化，用变量初始化

//t++；//编译出错

p=＆b；//const指针可以指向const和非const对象

q=＆b；//合法

return 0；

}