C和指標 const指標

2021-08-27 02:33:33 字數 3915 閱讀 7704

一,入門

const 指標

指標指向的內容不能變,指標可以改變指向

指向const的指標

指標不可以改變指向,指標指向內容可以變

#include "stdio.h" 

int main()

二,深度解析

大致說來其可分為三種情況: const修飾指標,const修飾引用,const修飾指標的引用.

const修飾指標

const修飾指標本身

const修飾指標所指的變數(或物件)

const修飾指標本身和指標所指的變數(或物件)

1)const修飾指標本身

這種情形下,指標本身為常量,p不可改變,任何修改指標本身的行為都是非法的.

例如:

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 *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

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*便可.

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; //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

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

指標和引用,const 指標和const 引用

指標和引用是在使用中經常弄混淆的兩個概念。引用 reference 為物件起了另外乙個名字,用符號 表示。name,例如 int i 1024 int ref i 一般在初始化變數時,初始值會被拷貝到新建立的物件中,然而定義引用時,程式把引用和它的初始值繫結 bind 在一起,而不是將初始值拷貝給引...

指向const的指標和const指標

指向const的指標 int gorp 16 int chips 12 const int p snack gorp 其中p snack指向乙個const int。p snack 20 不被允許,p snack的值為const,禁止修改p snack指向的值,p snack chips 可以執行,p...

const指標和指向const物件的指標

1.有關const指標和指向const物件指標的一道題 首先要說明的是怎麼來判斷const指標還是指向const的指標 如果const後面跟的是型別,那麼const是用來修飾物件的,所以它是指向const物件的指標 但是如果const後面跟的是指標本身,那麼const是用來修飾指標的,所以它是con...