const修饰指针和引用释疑

雨点打透心脏的1/2处 2023-10-07 14:31 35阅读 0赞

今天来说说const修饰指针和引用，接下来从三个部分来说：const修饰指针,const修饰引用,const修饰指针的引用.

**一、const修饰指针**

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

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

**1.const修饰指针本身**

这种情形下,指针本身为常量,不可改变,任何修改指针本身的行为都是非法的.例如:

const int a = 1; 
    const int b = 2; 
    int i = 3; 
    int j = 4; 
    int* const pi = &i; //ok, pi的类型为int* const , &i的类型为int* const 
    int* const pi = &a; //error, pi的类型为int* const, &a的类型为const int* const 
    pi = &j; //error, 指针是常量,不可变 
    *pi = a; //ok, *pi并没有限定是常量 ,可变

由此看出，pi是常量，常量在初始化和赋值时，类型必须严格一致。也就是  
const修饰指针本身时，=号两边的变量类型必须严格一致，否则不能匹配。

**2.const修饰指针指向的变量(或对象)**  
此种情形下,通过间接引用指针不可改变变量的值,假设指针为p,则\*p不可变,下面以例子说明:

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

两者毫无二致,这也没什么技术上的优劣之分,也就是说const int与int const可以互换.建议大家熟悉这两种形式，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; 
    // 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\*便可.

**二、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,不存在这种形式,没有意义

**三、const修饰指针的引用**  
引用只是个别名,这里与修饰指针类似,又分为三种情况:  
(1) 先给个例子：

const int *pi = &a; 
    const int *&ri = pi; 
    //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 
    ri = &a; //ok
    ri = &i; //ok
    const int *pi1=&a;
    const int *pi2=&i;
    ri = pi1; //ok
    ri = pi2; //ok
    *ri = i; //error
    *ri = a; //error

注意这与1-(2)的区别.

(2)用例子说明:

int *const &ri = &i;

去掉ri左边的&号,则为int \*const ri,因为ri是别名,故ri的类型应与赋值的数类型一致,ri类型为int \*const,&i为int \*const,可以这么做.

int *const &ri = pi; //error,类型不合,一为int *const ,一为int *
    int *const &ri = &a; //error,类型不合,一为int *const,一为const int* const
    (*ri)++; //ok
    i++; //ok
    ri = &i; //error

这种情况下,ri为常量,不可更改.  
(3)用例子说明：

const int* pi = &j; 
    const int* const &ri = pi; //or int const * const &ri = pi;ok 
    const int* const &ri = &i; //ok

ri是pi的别名，pi的类型应与ri一致。拿掉&，得const int\* const ri ，把const ri看作一体,很容易得出ri的类型信息，就象前面2-(3)所讨论的一样，可以得到赋给ri的只要含有类型int\* 即可。pi的类型为int\*,&i的类型为int\* const ,可以这么做.

const int * const &ri = &a; //ok
    ri++;  //error
    *ri = 6;  //error

**更多C语言精彩内容欢迎B站搜索“[千锋教育][Link 1]”或者扫码领取全套资料**

新版C语言程序设计基础入门视频，这绝对是C语言教程天花板！

[Link 1]: https://space.bilibili.com/146668655?spm_id_from=333.337.0.0