(转)话说C语言const用法

const在C语言中算是一个比较新的描述符，咱们称之为常量修饰符，意即其所修饰 的对象为常量(immutable)。 咱们来分状况看语法上它该如何被使用。

一、函数体内修饰局部变量。 例： void func(){

const int a=0;

}

首先，咱们先把const这个单词忽略不看，那么a是一个int类型的局部自动变量， 咱们给它赋予初始值0。

而后再看const。 const做为一个类型限定词，和int有相同的地位。 const int a; int const a; 是等价的。

因而此处咱们必定要清晰的明白，const修饰的对象是谁，是a,和int没有关系。

const 要求他所修饰的对象为常量，不可被改变，不可被赋值，不可做为左值（l-value)。

这样的写法也是错误的： const int a;

                                a=0; // 非法，a不可变

这也是一个很常见的使用方式： const double pi=3.14;在程序的后面若是企图对pi再次赋值或者修改就会出错。

而后看一个稍微复杂的例子。 const int* p; 仍是先去掉const 修饰符号，获得：int *p。

注意，下面两个是等价的。 int* p; int *p;

其实咱们想要说的是，对于int *p：*p是int类型变量。那么显然，p就是指向int类型变量的指针，即p所指向的内存块内所存储的数据为*p。

同理 const int* p; 其实等价于 const int (*p); int const (*p); 即，*p是常量。也就是说，p指向的数据是常量，也就是说：*p不可变，而p可变。

因而 p+=8; //合法

       *p=3; //非法，p指向的数据是常量。

那么如何声明一个自身是常量的指针呢？

方法是让const尽量的靠近p;即：int* const p; const右面只有p,显然，它修饰的是p,说明p不可被更改，也就是说：*p可变，而p不可变。

首先把const去掉，能够看出int *p：p是一个指向 int类型变量的指针。 因而 p+=8; //非法，p不可变

                                                                                                  *p=3; //合法

再看一个更复杂的例子。

它是上面两者的综合 const int* const p; 说明p本身是常量，且p指向的int类型变量也是常量。也就是说：*p不可变，而p也不可变。

因而 p+=8; //非法，p不可变

      *p=3; //非法，*p不可变

const 还有一个做用就是用于修饰常量静态字符串。

例如： const char* name=David;

若是没有const,咱们可能会在后面有意无心的写name[4]='x'这样的语句，这样会致使对只读内存区域的赋值，而后程序会马上异常终止。

有了 const,这个错误就 能在程序被编译的时候就当即检查出来。

这就是const的好处：让逻辑错误在编译期被发现。

const 还能够用来修饰数组 const char s[]=David; 与上面有相似的做用。

二、在函数声明时修饰参数 来看实际中的一个例子。

void * memmove(void *dst, const void *src, size_t len); // 这是标准库中的一个函数，用于按字节方式复制字符串（内存）。

它的第一个参数：是将字符串复制到哪里去（destination),即目的地，这段内存区域必须是可写的，所以这个参数不能用const修饰。

它的第二个参数：是要将什么样的字符串复制出去，咱们对这段内存区域只作读取，不写，所以这个参数用const修饰。

因而，咱们站在这个函数本身的角度来看:

src 这个指针，它所指向的内存内所存储的数据(*src)在整个函数执行的过程当中是不变的。因而src所指向的内容(*src)是常量。因而*src就须要用const修饰。

例如，咱们这里这样使用它：

const char* s=hello;

char buf[100];

memmove(buf,s,6); //这里其实应该用strcpy或memcpy更好

若是咱们反过来写: memmove(s,buf,6); 那么编译器必定会报错。

这个报错的事实是：咱们常常会把各类函数的参数的顺序写反。

其实是编译器在此时帮了咱们大忙。若是编译器静悄悄的不报错，(在函数声明处去掉 const便可),那么这个程序在运行的时候必定会崩溃。

这里还要说明的一点是：在函数的参数声明中，const通常用来声明指针而不是基本类型变量。

例如，上面的memmove()函数中的size_t len这个参数,在函数实现的时候能够彻底不用更改len的值，那么是否应该把len也声明为常量呢？

能够这么作。咱们来分析这么作有什么优劣。

若是len加了const,那么对于这个函数的调用者，能够防止他在实现这个函数的时候修改不须要修改的值(len),这样很好。

可是： 1 这个修饰符号毫无心义，咱们仍然能够传递一个常量整数或者一个很是量整数过去，反正对方得到的只是咱们传递的一个copy。

          2 暴露了实现，我不须要知道你在实现这个函数的时候是否修改过len的值。

因此综合1和2，const通常只用来修饰指针。

再看一个复杂的例子。

int execv(const char *path, char *const argv[]);

着重看第二个参数：char *const argv[]。

若是去掉const,咱们能够看出 char * argv[]; argv是一个数组，它的每一个元素都是char *类型的指针。

若是加上const.那么const修饰的是谁呢？

它修饰的是一个数组argv[]：意思就是说这个数组中的元素是只读的。

那么这个数组中的元素的是什么类型呢？是char *类型的指针，也就是说指针是常量，而它指向的数据不是。 因而 argv[1]=NULL; //非法

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

三、全局变量。

咱们的原则依然是：尽量少使用全局变量。

咱们的第二条规则是：尽量多使用const。

若是一个全局变量只在本文件中使用，那么用法和前面所说的函数局部静态变量没有什么区别。

/* MyFile.c */

static const double pi=3.14;

而若是它要在多个文件间共享，那么就牵扯到一个存储类型的问题。有两种方式：

1.使用extern修饰

 /* file1.h */

extern const double pi;

/* file1.c */

const double pi=3.14;

而后在其余须要使用pi这个变量的文件中：#include file1.h 或者，本身把那句外部变量声明复制一遍就好。

这样作的结果是：整个程序连接完后，全部须要使用pi这个变量的文件共享同一个pi存储区域。

2.使用static静态外部存储类

/* constant.h */

static const pi=3.14;

在须要使用这个变量的*.c文件中，必须包含这个头文件。 前面的static必定不能少。不然连接的时候会报告说该变量被屡次定义。

这样作的结果是：每一个包含了constant.h的*.c文件，都有一份该变量本身的copy, 该变量实际上仍是被定义了屡次，占用了多个存储空间，不过在加了static关键字 后，解决了文件间重定义的冲突。

坏处是：浪费了存储空间，致使连接完后的可执行文件变大。

可是一般，这个小小几个字节的变化，不是问题。

好处是：你不用关心这个变量是在哪一个文件中被初始化的。

最后，说说const的做用。

const 的好处：引入了常量的概念，让咱们不要去修改不应修改的内存。

直接的做用就是：让更多的逻辑错误在编译期被发现。因此咱们要尽量的多使用const。

可是不少人并不习惯使用它，更有甚者，是在整个程序 编写／调试 完后才补 const。若是是给函数的声明补const,尚好。

若是是给 全局／局部变量补const,那 么……那么，为时已晚，无非是让代码看起来更漂亮了。

关于const的使用，曾有一 个笑话说，const 就像安全套，事前要记牢。若是作完后才想起来该用而忘了用， 呵呵……呵呵……