关于const用法的一些说明(网络收集)

const说明指针变量，组合的情况可能会显得很复杂。使用指针时要涉及两个目标，即指针本身和指针所指的对象。关于const指针变量，可归结为以下三种：
　　1.指向常量的指针变量；
　　2.常指针变量；
　　3.指向常量的常指针变量。
　　下面来分别谈谈这三种情况。

一、指向常量的指针变量：
声明格式：　const type * var_name;
或　type const * var_name;
特点：　可改值。
　　将指针声明冠以const，使指向的对象为常量，而不是指针为常量。注意：指向常量的指针不一定指向真正的常量，它也可以指向常量，只是从该指针的角度来看，它所指向的对象是常量，通过该指针不能修改它指向的对象。它还可以指向其它的对象，可以不初始化。
eg:
int a = 0,b = 1;
const int c = 3;
const int* pi; //等同于 (const int*) pi;
pi = &a;
*p = 10; //错误：不能修改它指向的对象。
a = 10;
pi = &b;
*pi = &b;
*pi = 20; //错误：不能修改它指向的对象。
b = 20;
pi = &c;
*pi = &c;
*pi = 30; //错误：不能修改它指向的对象。
eg2:
const char* pc = "asdf";
pc[3] = 'a'; //错误：不能修改它指向的对象。
pc = "ghik";
eg3:
const char* step[3] =
{"left","right","hop"};
step[2] = "skip";
step[2][1] = 'i'; //错误：不能修改它指向的对象。

二、常指针常量：
声明格式： type* const var_name;
或 type const* var_name;
特点：　可改对象。
　　要把指针本身，而不是它指向的对象声明为常量，采用运算符　*const，必须初始化，通过该指针可以修改它指向的对象，但它不可以指向其他的对象。
eg:
int a = 0,b = 1;
int* const pi = &a; //等于　int* (const pi) = &a;
*pi = 10;
pi = &b; //错误：pi本身为常量，不能指向其他对象。
eg2:
char const *pc = "asdf"; //注意：“并没有 const* 声明符，所以出现在 * 之前的 const 是作为基础类型的一部份。”
pc[3] = 'a';
pc = "ghjk"; //错误：不能指向其它对象。
eg3:
const char* step[3] =
{"left","right","hop"};
step[2] = "skip"; //错误：不能指向其它对象。
step[2][1] = 'i';

三、指向常量的常指针变量：
声明格式： const type * const var_name;
特点：　值与对象均不能改。
　　要使两个目标都是常量，两者都要声明为　const 。
eg:
int a = 0,b = 1;
const int c = 3;
const int* const pi = &a; //相当于： (const int*)(const pi) = &a;
*pi = 10; //错误：不能修改它的对象。
a = 10;
pi = &b; //错误：不能指向其它对象。
eg2:
const char* const pc = "asdf";
pc[3] = 'a'; //错误：不能修改它的对象。
pc = "ghik"; //错误：不能指向其它对象。
eg3:
const char* const step[3] =
{"left","right","hop"};
step[2] = "skip"; //错误：不能指向其它对象。
step[2][1] = 'i'; //错误：不能修改它的对象。

　　一般的，当声明中出现 const 描述符时，它修饰的是紧跟其后的声明元素或者在 const 成员函数声明中函数的 this 指针。
　　注意：可以将变量的地址赋给指向常量的指针变量，不会因此有什么害处，但是，常量的地址不能赋给无约束的指针。
eg:
int a = 1;
const int c = 2;
const int* p1 = &c;
const int* p2 = &a;
int* p3 = &c; //非法！
int* const p4 = &c; //非法！ 指针常量 p4 能够改值。
const int* const p5 = &c;       

为了防止指针指向的常量被修改，C标准对于指针间赋值有一个规定，就是左值必须包含右值的所有限定词。 这就限定了一个指向const对象的指针不能赋值给指向非const对象的指针，但反过来就允许。这个规定初看上去非常合理，但其效用其实只限于一级指 针，二级指针间的赋值即使满足规定也不再安全，下面举个例子：

const int i=10;
const int **p1;
int *p2;
p1 = &p2;
*p1 = &i;
*p2 = 20;

现 在你会发现，作为常量的i的值被修改了。i的值被修改的关键原因在*p1=&i;这一句，&i是一个指向常量的一级地址，如果没有二级指 针p1，受限于上述规定，作为左值接受这个一级地址的指针就必须也是一个指向常量的一级指针，于是就不能进行下一步赋值20的操作。因此，正由于指向 const对象的二级指针p1的出现，使得*p1也是一个指向const的指针，于是*p1=&i能够合法地运行，常量i的值被修改也就成了一个 预想中的结果了。有鉴于此，某些编译器也会限定非const二级指针之间的赋值，规定上面的p1=&p2也是非法的。

一些说明：

1. 限定符声明变量只能被读

const int i=5;

int j=0;

...

i=j; file://非法，导致编译错误

j=i; file://合法

2. 必须初始化

const int i=5; file://合法

const int j; file://非法，导致编译错误

3. 在另一连接文件中引用const常量

extern const int i; file://合法

extern const int j=10; file://非法，常量不可以被再次赋值

4. 便于进行类型检查

用const方法可以使编译器对处理内容有更多了解。

#define I=10

const long &i=10; /*dapingguo提醒：由于编译器的优化，使

得在const long i=10; 时i不被分配内存，而是已10直接代入

以后的引用中，以致在以后的代码中没有错误，为达到说教效 果，特别

地用&

i明确地给出了i的内存分配。不过一旦你关闭所

有优化措施，即使const long i=10;也会引起后面的编译错误。*/

char h=I; file://没有错

char h=i; file://编译警告，可能由于数的截短带来错误赋值。

5. 可以避免不必要的内存分配

#define STRING "abcdefghijklmn\n"

const char string[]="abcdefghijklm\n";

...

printf(STRING); file://为STRING分配了第一次内存

printf(string); file://为string一次分配了内存，以后不再分配

...

printf(STRING); file://为STRING分配了第二次内存

printf(string);

...

由于const定义常量从汇编的角度来看，只是给出了对应的内存地址，

而不是象#define一样给出的是立即数，所以，const定义的常量在

程序运行过程中只有一份拷贝，而#define定义的常量在内存中有

若干个拷贝。

6. 可以通过函数对常量进行初始化

int value();

const int i=value();

dapingguo说：假定对ROM编写程序时，由于目标代码的不可改写， 本语句将

会无效

，不过可以变通一下：

const int &i=value();

只要令i的地址处于ROM之外，即可实现：i通过函数初始化，而其

值有不会被修改。

7. 是不是const的常量值一定不可以被修改呢？

观察以下一段代码：

const int i=0;

int *p=(int*)&i;

p=100;

通过强制类型转换，将地址赋给变量，再作修改即可以改变const常量值。

8. 请分清数值常量和指针常量，以下声明颇为玩味：

int ii=0;

const int i=0; file://i是常量，i的值不会被修改

const int *p1i=&i; file://指针p1i所指内容是常量，可以不初始化



int * const p2i=ⅈ file://指针p2i是常量，所指内容可修改

const int * const p3i=&i; file://指针p3i是常量，所指内容也是常量

p1i=ⅈ file://合法

*p2i=100; file://合法