指针和const的用法

转自：http://www.cnblogs.com/witty/archive/2012/04/06/2435311.html

const是一个C语言（ANSI C）的关键字，它限定一个变量不允许被改变,产生静态作用。使用const在一定程度上可以提高程序的安全性和可靠性。

常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。（当然，我们可以偷梁换柱进行更新：）

const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。

（1）可以定义const常量，具有不可变性。 
　　例如：const int Max=100; Max++会产生错误; 
　　（2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。
　　例如： void f(const int i) { .........} 编译器就会知道i是一个常量，不允许修改； 
　　（3）可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。 同宏定义一样，可以做到不变则已，一变都变！
　　如（1）中，如果想修改Max的内容，只需要：const int Max=you want;即可！ 
　　（4）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。 还是上面的例子，如果在函数体内修改了i，编译器就会报错； 
　　例如： void f(const int i) { i=10;//error! } 

（5） 可以节省空间，避免不必要的内存分配。 例如： 
　　#define PI 3.14159 //常量宏 
　　const double Pi=3.14159; //此时并未将Pi放入RAM中 ...... 
　　double i=Pi; //此时为Pi分配内存，以后不再分配！ 
　　double I=PI; //编译期间进行宏替换，分配内存 
　　double j=Pi; //没有内存分配 
　　double J=PI; //再进行宏替换，又一次分配内存！ 
　　const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是像#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干份拷贝。 
　　（6） 提高了效率。 
　　编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

例：为什么下面的例子在使用一个const变量来初始化数组，ANSI C的编译器会报告一个错误呢？

const int n = 5;

int a[n];

答案与分析：

1）这个问题讨论的是“常量”与“只读变量”的区别。常量，例如5， "abc"，等，肯定是只读的，因为常量是被编译器放在内存中的只读区域，当然也就不能够去修改它。而“只读变量”则是在内存中开辟一个地方来存放它的值，只不过这个值由编译器限定不允许被修改。C语言关键字const就是用来限定一个变量不允许被改变的修饰符（Qualifier）。上述代码中变量n被修饰为只读变量，可惜再怎么修饰也不是常量。而ANSI C规定数组定义时长度必须是“常量”，“只读变量”也是不可以的，“常量”不等于“不可变的变量”。但是在C++中，局部数组是可以使用变量作为其长度的。

2）但是在标准C++中，这样定义的是一个常量，这种写法是对的。实际上，根据编译过程及内存分配来看，这种用法本来就应该是合理的，只是ANSI C对数组的规定限制了它（实际上用GCC或VS2005编译以上代码，确实没有错误产生，也没有给出警告）。

3）那么，在ANSI C中用什么来定义常量呢？答案是enum类型和#define宏，这两个都可以用来定义常量。

例：下面的代码编译器会报一个错误，请问，哪一个语句是错误的呢？

typedef char * pStr;

char string[4] = "bbc";

const char *p1 =" string"; //1式

const pStr p2 =" string"; //2式

p1++;

p2++;

答案与分析：

问题出在p2++上。

1）const使用的基本形式： const type m;限定m不可变。替换基本形式中的m为1式中的*p1，替换后const char *p1;限定*p1不可变，当然p1是可变的，因此问题中p1++是对的。替换基本形式中的type为2式中的pStr，替换后const pStr m;限定m不可变，题中的pStr就是一种新类型，因此问题中p2不可[1]  变，p2++是错误的。

下面分别用const限定不可变的内容是什么？

1）const在前面

const int nValue； //nValue是const

const char *pContent; //*pContent是const, pContent可变

const char* const pContent; //pContent和*pContent都是const

2）const在后面，与上面的声明对等

int const nValue; //nValue是const

char const * pContent; //*pContent是const, pContent可变

char* const pContent; //pContent是const,*pContent可变

char const* const pContent; //pContent和*pContent都是const

答案与分析：

const和指针一起使用是C语言中一个很常见的困惑之处，在实际开发中，特别是在看别人代码的时候，常常会因为这样而不好判断作者的意图，下面讲一下我的判断原则：

const只修饰其后的变量，至于const放在类型前还是类型后并没有区别。如：const int a和int const a都是修饰a为const。注意*不是一种类型，如果*pType之前是某类型，那么pType是指向该类型的指针

一个简单的判断方法：指针运算符*，是从右到左，那么如：char const * pContent，可以理解为char const (* pContent)，即* pContent为const，而pContent则是可变的。[1] 

int const * p1,p2;

p2是const；(*p1)是一整体，因此(*p1)是const，但p1是可变的。int * p1,p2只代表p1是指向整型的指针，要表示p1、p2都是指针是需写成int * p1,* p2。所以无论是* const p1,p2还是const * p1,p2，里面的*都是属于p1的。

int const * const p1,p2;

p2是const，是前一个const修饰的，*p1也被前一个const修饰，而p1被后一个const修饰。

int * const p1,p2;

p1是const，（* const p1）是整体，所以const不修饰p2。

指针指向及其指向变量的值的变化

const在*的左边，则指针指向的变量的值不可直接通过指针改变（可以通过其他途径改变）；在*的右边，则指针的指向不可变。简记为“左定值，右定向”。

1）指针指向的变量的值不能变，指向可变

int x = 1;

int y = 2;

const int* px = &x;

int const* px = &x; //这两句表达式一样效果

px = &y; //正确，允许改变指向

*px = 3; //错误，不允许改变指针指向的变量的值

2）指针指向的变量的值可以改变，指向不可变

int x = 1;

int y = 2;

int* const px = &x;

px = &y; //错误，不允许改变指针指向

*px = 3; //正确，允许改变指针指向的变量的值

3）指针指向的变量的值不可变，指向不可变

int x = 1;

int y = 2;

const int* const px = &x;

int const* const px = &x;

px = &y; //错误，不允许改变指针指向

*px = 3; //错误，不允许改变指针指向的变量的值

补充

在c中，对于const定义的指针，不赋初值编译不报错，

int* const px;这种定义是不允许的。（指针常量定义的时候对其进行初始化）

int const *px;这种定义是允许的。（常指针可以再定义的时候不初始化）

但是，在C++中

int* const px;和const int* const px;会报错，const int* px;不报错。

必须初始化指针的指向int* const px = &x;const int* const px=&x;

强烈建议在初始化时说明指针的指向，防止出现野指针！

一) 常量指针。

指针指向的对象是常量，那么这个对象不能被更改。

在C/C++中，常量指针是这样声明的：

1）const int *p;

2）int const *p;

常量指针的使用要注意，指针指向的对象不能通过这个指针来修改，可是仍然可以通过原来的声明修改，也就是说常量指针可以被赋值为变量的地址，之所以叫做常量指针，是限制了通过这个指针修改变量的值。例如：

int a = 5;

const int b = 8;

const int *c = &a; // 这是合法的，非法的是对c的使用

*c = 6; // 非法，但可以这样修改c指向的对象的值：a = 6;

const int *d = &b; // b是常量，d可以指向b，d被赋值为b的地址是合法的

细心的朋友在使用字符串处理函数的时候，应该会注意到这些函数的声明。它们的参数一般声明为常量指针。例如，字符串比较函数的声明是这样的：

int strcmp(const char *str1, const char *str2);

可是这个函数却可以接收非常量字符串。例如这段程序：

char *str1, *str2;//在此，自己的观点是str1，str2就是指向常量的指针，虽然没有const，str1[0]='w';程序崩溃

详解：http://blog.csdn.net/u012942555/article/details/48876447

str1 = "abcde1234";//"abcde1234"在常量区

str2 = "bcde";//"bcde"在常量区

if(strcmp(str1, str2) == 0)

{

printf("str1 equals str2.");

}

因为函数的参数声明用了常量指针的形式，就保证了在函数内部，那个常量不被更改。也就是说，对str1和str2的内容更改的操作在函数内部是不被允许的。（就目前的应用来看，我觉得设置常量指针就是为函数参数声明准备的，不然还真不知道用在什么地方呢，呵呵！）

虽然常量指针指向的对象不能变化，可是因为常量指针是一个变量，因此，常量指针可以不被赋初始值，且可以被重新赋值。例如：

const int a = 12;

const int b = 15;

const int *c = &a; // 为了简化代码，很多人习惯赋初始值

const int *d;

d = &a; // 这样当然是可以的

c = &b; // 虽然c已经被赋予初始值，可是仍然可以指向另一个变量

特点是，const的位置在指针声明运算符*的左侧。只要const位于*的左侧，无论它在类型名的左边或右边，都声明了一个指向常量的指针，叫做常量指针。

可以这么想，*左侧是常量，指针指向的对象是常量。

二) 指针常量

指针常量的值是指针，这个值因为是常量，所以不能被赋值。

在C/C++中，指针常量这样声明：

int a;

int *const b = &a; //const放在指针声明操作符的右侧

只要const位于指针声明操作符右侧，就表明声明的对象是一个常量，且它的内容是一个指针，也就是一个地址。上面的声明可以这么读，声明了一个常量b，它的值是变量a的地址（变量a的地址，不就是指向变量a的指针吗）。

因为指针常量是一个常量，在声明的时候一定要给它赋初始值。一旦赋值，以后这个常量再也不能指向别的地址。

虽然指针常量的值不能变，可是它指向的对象是可变的，因为我们并没有限制它指向的对象是常量。

三）指向常量的指针常量

顾名思议，指向常量的指针常量就是一个常量，且它指向的对象也是一个常量。

因为是一个指针常量，那么它指向的对象当然是一个指针对象，而它又指向常量，说明它指向的对象不能变化。

在C/C++中，这么声明：

const int a = 25;

const int * const b = &a;

看，指针声明操作符左边有一个const，说明声明的是一个指向常量的指针。再看，指针声明操作符右边有一个const，说明声明的是一个指针常量。前后都锁死了，那么指向的对象不能变，指针常量本身也不能变。细细体味，相信能得其道，下面就不赘述了。

#include <iostream>
using namespace std;
void main()
{
char *a = "aaaa";
const char *b = "bcde";
char *const c = a;  
a="1234";//a[0] = 'x';崩溃，这说明了一个问题，开始赋值的“aaaa”在常量区，并不能修改，并且执行a="1234"后，a变c不变

//”aaaa“并没有修改，只是在另一个区域给"1234"分配了空间
const char *const d = b;
cout<<c<<endl;//aaaa
cout<<a<<endl;//1234
}

问题来了。

１）问：因为a是变量，a可以赋值为其它值，如"aaaa"。那么c指向a，当a变化了，c指向什么呢？

答：仍然指向"aaaa"。虽然a可以指向别的字符串，可是c仍然指向"aaaa"，也就是a开始指向的对象。

2）问：b是指向常量的指针变量，当b指向别的字符串，d怎么样？

答：d仍然指向b初始的字符串。

3）问：b可以变化，b指向的字符串不能变化，也就是说b[0]不能被重新赋值，可是b[1]可以被重新赋值吗？

答：原则上b指向的字符是常量，并没有限制下一个字符，应该可以被赋值。可是因为你使用字符串进行了初始赋值，而且编译器是静态编译的，C/C++程序就把b当作字符串指针来处理了，因此，当对下一个字符进行赋值时，编译能通过，运行崩溃。

指针变量能改指向，指针常量不能转向！