一、const限定符的作用

　　當我們在寫程序的時候，想定義一種變量，它的值不會被改變，這時就可以用const限定符來定義變量，也可稱它為常量，常量的定義必須要有初始值，否則編譯錯誤。其實際例子是用一個變量來表示緩沖區(qū)的大小的時候。

　　對內(nèi)置類型用const是比較通俗易懂的，其作用就是不能對用const定義了的變量進行修改(寫)，但可以進行拷貝(讀)。

const int bufSize = 512;    //正確
const int bufSize2;    //錯誤，const對象必須要初始化    
int buffer[bufSize];
 
const int a = 1;
int b = 2;
a = 3;    //錯誤，不能對常量進行賦值    
b = a;    //正確

二、const和引用

　　在我的理解中，引用就相當于一個常量，它在初始化時就已經(jīng)與一個對象綁定在一起，之后就不能綁定其他對象，這種專一的品質(zhì)非常值得我們學習。而當用const對引用進行定義時，它的作用就是說明該引用綁定的對象是一個常量，不能對該引用進行修改(事實上，常量引用綁定的對象不一定是常量，常量引用中的“常量”這兩個字的意思其實是引用覺得其綁定的對象是一個常量，但該綁定的對象是變量也是合法的，下面通過代碼詳細說明)。

//非常量引用
int a = 0;
int &r = a;
r = 1;    //通過操作引用來對a賦值，此時相當于a=1
 
//常量引用綁定常量
const int b = 1;    //b是一個常量
const int &r2 = b;    //正確
r2 = 5;      //錯誤，不能對常量引用進行修改
b = 5;    //錯誤
 
//常量引用綁定變量
int c = 1;
const int &r3 = c;    //正確，常量引用也可以綁定變量
r3 = 5;    //錯誤，不可修改常量引用
int d = r3;    //正確，常量引用可讀，該值為c
c = 5;    //正確，可修改變量
 
//非常量引用不可綁定常量
const int e = 1;
int &r4 = e;    //錯誤

　　以上四種情況已說明const和引用的關系，為何第四種情況中不可用非常量引用綁定常量呢，這是因為我們已經(jīng)定義了e是一個不可修改的常量，假如我們用非常量引用成功綁定了它，并且可以通過修改引用來使e的值改變，這不就違背了e作為常量其值不可改變的理念了嗎，所以第四種情況編譯器是會報錯的。

　　常量引用中的const的作用是針對引用綁定的對象的，指所綁定的對象是一個常量，這叫做底層const。

三、const和指針

　　引用不是一個對象，因此const不能針對引用起作用，只能對引用的綁定對象起作用。但指針是一個對象，所以指針和const之間有三種組合方式：1.常量指針，2.指向常量的指針，3.指向常量的常量指針，其三者作用如下代碼所示。

//1、常量指針
//常量指針指向變量，即常量指針中的地址不能修改
int a = 1;
int b = 2;
int *const p = &a;    //正確，常量指針可以指向變量
p = &b;    //錯誤，常量指針中的地址值不能修改
*p = 2;    //正確，p的解引用是a的值，a是變量，可以修改該值
 
//2、指向常量的指針
//即指針中的地址可以修改，但指向的對象是常量不能用解引用修改值(實際上指向的對象可以是變量)
int c = 3;
const int d = 4;
int e = 5;
const int f = 6;
int const *p2 = &c;    //正確，指向常量的指針可以指向變量
const int *p3 = &d;    //正確，指向常量的指針指向常量
p2 = &e;    //正確，可以改變指向的地址
p3 = &f;     //正確
*p2 = 0;    //錯誤，雖然p2實際指向的是一個變量，但操作p2的解引用時p2把指向的對象看作常量，因此不能通過解引用來修改對象的值
c = 0;    //正確，不能通過p2的解引用修改c，但c自身是變量可以修改
*p3 = 0;    //錯誤，同理p2
f = 0;    //錯誤
 
//3、指向常量的常量指針
//即指針中的地址不可以修改，指向的對象是常量也不能用解引用修改值(實際上指向的對象可以是變量)
int g = 1;
const int h = 2;
const int *const p4 = &g;    //正確
const int *const p5 = &h;    //正確
p4 = &h;    //錯誤，不能修改值
*p4 = 0;    //錯誤，不能修改其解引用

　　對象的類型確定了對象的操作，因此指向常量的指針它的“常量”兩字不是限制指針指向的對象必須是常量，而是限制了指針的解引用操作。因為指向常量的指針和常量引用一樣，是一個自以為是的家伙，它認為自己指向的一定是一個常量，所以對指向常量的指針進行解引用，讓指針認為在對一個常量進行修改，因此這是非法的行為。

四、頂層const和底層const

1、頂層const

　　何為頂層const，其定義為對象本身是一個常量，因此對一切的內(nèi)置類型常量而言，所有的const都是頂層const，而對于指針而言，常量指針是頂層const，對于引用則沒有頂層const的概念，以下代碼都是頂層const。

const int a = 1;
const double val = 3.14;
const string str = “hello”;
int *const p = &a;

　　頂層const的對象一旦完成初始化，就不能修改其值，但可以作為被拷貝對象進行拷貝操作，如下代碼所示。

const int b = 1;
b = 2;    //錯誤，頂層const不能修改值
int c = b;    //正確，頂層const可以被拷貝
int *const p2 = &b;
*p2 = 0;    //錯誤，實際指向的為常量，不能修改其解引用
p2 = &c;    //錯誤，頂層const不能修改值
 
int *const p3 = &c;
*p3 = 3;    //正確，實際指向的為變量，可以修改其解引用
 
const int *p4 = p2;    //正確，頂層const可以被拷貝
*p4 = 0;    //錯誤，p4是底層const(下面解釋)，不能修改其解引用

　　有些朋友可能對const int *p3這句定義語句有疑問，其實它和int const *p3是一樣的，都是指向常量的指針，也是一個底層const(下面介紹)，而以上代碼說明頂層const對象不能修改，但可以被拷貝，因為被拷貝的過程中，是可以忽略頂層const的。

2、底層const

　　底層const這個概念只在指針和引用上有效，其定義是該指針指向或該引用綁定的對象是常量。因此指針可以有頂層const和底層const，而引用只有底層const。

int a = 0;
int const *p = &a;    //底層const
const int &r = a;    //底層const

　　很多朋友可能分不清一個指針到底是底層const還是頂層const，這里可以教大家一個方法，就是看變量名最近的聲明符是什么，例如const int *p，最近的聲明符是*，因此他是一個指針，第二個聲明符才是const，因此他是一個指向常量的指針；又例如int *const p2，最近的聲明符是const，因此p2是一個常量，第二個聲明符才是*，因此它是一個常量指針。其實大家只要記住一個就行，各人有各人的方法，最緊要自己覺得好用啦。

　　了解了底層const，那么我們分析一下底層const可以進行哪些操作，以下為代碼。

int a = 0;
const int b = 0;
int const *p = &a;    //底層const可以指向常量也可以指向變量，因為對于&a該類型可以從int*轉換為const int*，因此可以說成對象被拷貝時可以忽略其頂層const
 
//對于引用的底層const，即是常量引用
const int &r = a;    //綁定一個變量
r = 0;    //錯誤，引用的底層const不可以修改值。
int c = r;  //正確
const int d = r;    //正確
int &r2 = r;    //錯誤
const int r3 = r;    //正確  
 
//對于指針的底層const，即指向常量的指針
//修改指針的值
p = &b;    //正確，指針的底層const可以修改值
*p = 2;    //錯誤，指針的底層const不可以修改解引用的值
 
//指針被拷貝
int *p2 = p;    //錯誤
int *const p3 = p;    //錯誤
int const *p4 = p;    //正確
const int *const p5 = p;    //正確，p5有頂層和底層const 

　　對于引用的底層const，因為引用沒有頂層const，對于它的操作特性，可以從它綁定了一個常量這個基礎去理解，實際它不一定綁定常量，但在使用常量引用時要看成他始終綁定了一個常量，那么它的修改和被拷貝是否允許就比較清楚了。

　　對于指針的底層const，指針把自己指向的對象視為常量，所以我們修改解引用的值時相當于修改指向的那個常量對象的值，這是不允許的，所以編譯器報錯。但指針不是常量指針(沒有頂層const)，因此可以修改指針的值(指向的對象可以改變)。當有底層const的指針用作被拷貝的對象是，其底層const就不能忽略了，拷入和拷出的對象必須都要有底層const才能對底層const指針進行拷貝操作。

對指針const限定符的總結：

1. 頂層const不能修改值，但其解引用可能可以修改(根據(jù)實際指向的對象決定)
2. 頂層const作為被拷貝值時，沒有限制，可以被忽略
3. 底層const可以修改值，但其解引用不能修改
4. 底層const在用作拷貝操作時，要求拷入與拷出值都有相同的底層const(都是底層const，或都不是)，不能忽略。

到此這篇關于C++ const限定符以及頂層const和底層const的案例詳解的文章就介紹到這了,更多相關C++ const限定符以及頂層const和底層const內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！