关于指针的一些总结由刀豆文库小编整理，希望给你工作、学习、生活带来方便，猜你可能喜欢“指针总结”。
如果const在*左边,const修饰值intconst*pi
如果const在*右边,const修饰指针int*constpi;
其实这种问题你可以这样看，const后面如果有*p之类的，就是p能改，*p不能改，也就是指针能改，指针的值不能改，intconst*p后面有*p，所以是*p不能改，int*constp是p不能改，*p能改～！其他的类似。
constint*p;
intconst*q;
int*constr=&i;
1,声明了一个指针p,它指向一个int型的常量，p可以再指向别的变量，但这个int型的值不能被改变
2,同上.3,声明了一个常指针p,它被一个int型变量的地址初始化，这个指针将不再允许指向别的变量，而这个int变量的值是可以改变的。
const修饰指针和引用的用法,对于初学C++的人直是讳莫如深,不知所云.一旦你了解了其用法,一切便不值一哂了.下面我为读者一一释疑:
大致说来其可分为三种情况:const修饰指针,const修饰引用,const修饰指针的引用.1.const修饰指针
const修饰指针又可分为三种情况:
const修饰指针本身
const修饰指针所指的变量(或对象)
const修饰指针本身和指针所指的变量(或对象)
(1).const修饰指针本身
这种情形下,指针本身为常量,不可改变,任何修改指针本身的行为都是非法的.例如:constinta=1;
constintb=2;
inti=3;
intj=4;
int*constpi=&i;//ok,pi的类型为int*const,&i的类型为int*const
int*constpi=&a;//error,pi的类型为int*const,&a的类型为constint*const
pi=&j;//error,指针是常量,不可变
*pi=a;//ok,*pi并没有限定是常量,可变
由此看出，pi是常量，常量在初始化和赋值时，类型必须严格一致。也就是const修饰指针本身时，=号两边的变量类型必须严格一致，否则不能匹配。
(2).const修饰指针指向的变量(或对象)
此种情形下,通过间接引用指针不可改变变量的值,假设指针为p,则*p不可变,下面以例子说明:
constint*pi=&a;
//orintconst*pi=&a;
//两者毫无二致,不过BS喜欢前者,这也没什么技术上的优劣之分,也就是说constint与intconst可以互换.建议大家熟
//悉这两种形式,为简洁便,以后统统用前者.//ok,const并不修饰指针本身,pi对赋值类型
//没要求,但pi是int*型指针，所以所赋的必须是个地址值。
constint*pi=&i;//ok,pi可赋值常量的地址,又可赋变量的地址
constint*pi1=&a;
constint*pi=pi1;//ok
*pi=j;//error,*pi不可变,不能更改指针的间接引用形式
pi=&j;//ok,pi可变
pi=&b;//ok,pi可变
pi++;//ok
--pi;//ok
由此可见，pi是变量，可以赋值常量和变量的值,正如一个整型变量可赋整型数和整型变量一样.const修饰的不是指针本身，而是其间接引用，=号两边的类型不必严格匹配，如：constint*pi=&a;中，pi的类型为int*,而&a的类型为constint*const,只要其中含有int*就可以。又如：constint*pi=&j;中，pi的类型为int*,而&j的类型为int*const,它向pi赋值并无大碍。
(3)const修饰指针本身和指针所指的变量(或对象)
设有指针p,此种情形下,p和*p都不可变.举例如下:
constint*constpi=&a;
//orintconst*constpi=&a;
//将constpi看作一体,就与(2)所述相同,只是要求pi必须为const,正如上所说，=号两边的类型不必严格匹配，但必须含有int*,&a的类型为constint*const,含有int*,所以可以赋值。constint*constpi=&i;//ok,&i类型为int*const,含有int*,可赋值。
constint*pi1=&j;
constint*constpi=pi1;//ok,pi1类型为int*
pi=&b;//error,pi不可变
pi=&j;//error,pi不可变
*pi=b;//error,*pi不可变
*pi=j;//error,*pi不可变
pi++;//error，pi不可变
++i;//ok,=号右边的变量(或对象)与所修饰的变量无关
a--;//error,a为const
这种情况，跟以上两种情形有联系。对constint*constpi=&a;我们可以这样看：constint*(constpi)=&a;(仅仅是表达需要)，将constpi看作一体，就与上述分类(2)符合。只要含有int*便可.2.const修饰引用
这种情况比较简单，没有象修饰指针那样繁复，因为引用和引用对象是一体的，所以引用被const修饰只有一种类型。
const修饰引用,引用本身不可变,但引用的变量(或对象)可以改变.例如:
constint&ri=a;//orintconst&ri=a;ok,ri本身是常量,引用不区分类型
constint&ri=i;//ok,引用不区分类型
ri++;//error,ri为常量,不可变
i++;//ok,=右边的变量与引用无关
ri=b;//error,ri为常量
i=j;//ok,=右边的变量与引用无关
int&constri=i;//error,不存在这种形式,没有意义
3.const修饰指针的引用
引用只是个别名,这里与修饰指针类似,又分为三种情况:
(1)
先给个例子：
constint*pi=&a;
constint*&ri=pi;
//orintconst*&ri=pi;
引用是引用对象的别名，正因为如此，ri是pi的别名，所以ri的类型必须与pi完全一致才行。这里pi的类型为int*,ri的类型也为int*，赋值可行。若constint*&ri=&a;正不正确？分析一下就知晓。ri类型为int*,&a的类型则为constint*const不匹配。
constint*&ri=&i;//error,类型不匹配，一为int*,一为int*constri=&a;//ok
ri=&i;//ok
constint*pi1=&a;
constint*pi2=&i;
ri=pi1;//ok
ri=pi2;//ok
*ri=i;//error
*ri=a;//error
注意这与1-(2)的区别.(2)
用例子说明:
int*const&ri=&i;
去掉ri左边的&号,则为int*constri,因为ri是别名,故ri的类型应与赋值的数类型一致,ri类型为int*const,&i为int*const,可以这么做.int*const&ri=pi;//error,类型不合,一为int*const,一为int*int*const&ri=&a;//error,类型不合,一为int*const,一为constint*const
(*ri)++;//ok
i++;//ok
ri=&i;//error
这种情况下,ri为常量,不可更改.(3)
用例子说明：
constint*pi=&j;
constint*const&ri=pi;//orintconst*const&ri=pi;ok
constint*const&ri=&i;//ok
ri是pi的别名，pi的类型应与ri一致。拿掉&，得constint*constri，把constri看作一体,很容易得出ri的类型信息，就象前面2-(3)所讨论的一样，可以得到赋给ri的只要含有类型int*即可。pi的类型为int*,&i的类型为int*const,可以这么做.constint*const&ri=&a;//ok
ri++;//error
*ri=6;//error
