const修饰指针和引用的用法

const修饰指针和引用的用法,对于初学C++的人直是讳莫如深,不知所云.

一旦你了解了其用法,一切便不值一哂了.下面我为读者一一释疑:

大致说来其可分为三种情况: const修饰指针,const修饰引用,const修饰指针的引用.

1.const修饰指针

const修饰指针又可分为三种情况:

a.const修饰指针本身

b.const修饰指针所指的变量(或对象)

c.const修饰指针本身和指针所指的变量(或对象)

(1).const修饰指针本身



(2).const修饰指针指向的变量(或对象)

此种情形下,通过间接引用指针不可改变变量的值,假设指针为p,则*p不可变,下面以例子说明:

const int *pi = &a;

//or int const *pi = &a;

//两者毫无二致,不过BS喜欢前者,这也没什么技术上的优劣之分,

//也就是说const
int与int const以互换.建议大家熟

//悉这两种形式,为简洁便,以后统统用前者.

//ok, const并不修饰指针本身,pi对赋值类型

//没要求 ,但pi是int*型指针，所以所赋的必须是个地址值。

const int *pi = &i; //ok ,pi可赋值常量的地址,又可赋变量的地址

const int *pi1 = &a;

const int *pi = pi1; //ok

*pi = j; //error,*pi 不可变,不能更改指针的间接引用形式

pi = &j; //ok,pi可变

pi = &b;
//ok,pi可变

pi++; //ok

--pi; //ok

由此可见，pi是变量，可以赋值常量和变量的值,正如一个整型变量可赋整型数和整型变量一样

.const修饰的不是指针本身，而是其间接引用，=号两边的类型不必严格匹配，

如：const int* pi = &a;

中，pi的类型为int*,而&a的类型为const int* const,

只要其中含有int*
就可以。又如：const int *pi = &j;

中，pi的类型为int*,而&j的类型为int* const,它向pi赋值并无大碍。

(3)const修饰指针本身和指针所指的变量(或对象)

设有指针p,此种情形下,p和*p都不可变.举例如下:

const int* const pi = &a;

//or int const* const pi = &a;

//将const pi看作一体,就与(2)所述相同,只是要求pi必须为const,

正如上所说，=号两边的类型不必严格匹配，

但必须含有int*, &a的类型为const int*
const,含有int*, 所以可以赋值。

const int* const pi = &i; //ok,
&i类型为int* const,含有int*, 可赋值。

const int *pi1 = &j;

const int *const pi = 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

这种情况，跟以上两种情形有联系。对const int* const pi =
&a;我们可以这样看：

const int*( const pi )= &a;(仅仅是表达需要)，将const
pi看作一体，就与上述分类(2)符合。

只要含有int*便可.

2.const修饰引用

这种情况比较简单，没有象修饰指针那样繁复，因为引用和引用对象是一体的，

所以引用被const修饰只有一种类型。

const修饰引用,引用本身不可变,但引用的变量(或对象)可以改变.例如:

const
int& ri = a; //or int const & ri =
a; ok, ri 本身是常量,引用不区分类型

const
int& ri = i; //ok,引用不区分类型

ri++;
//error, ri为常量,不可变

i++;
//ok,=右边的变量与引用无关

ri=b;
//error, ri为常量

i=j;
//ok,=右边的变量与引用无关

int
& const ri = i; //error,不存在这种形式,没有意义

3.const修饰指针的引用

引用只是个别名,这里与修饰指针类似,又分为三种情况:

(1)

先给个例子：

const int *pi = &a;

const int *&ri = pi;

//or int const *&ri = pi;

引用是引用对象的别名，正因为如此，ri是pi的别名，所以ri的类型必须与pi完全一致才行。

这里pi的类型为int*,ri的类型也为int*，赋值可行。若const int *&ri =
&a;正不正确？

分析一下就知晓。

ri类型为int*,&a的类型则为const int* const不匹配。

const int *&ri = &i;
//error,类型不匹配，一为int*,一为int* const