??撰寫程式程序中，我們有時不希望改變某個變數的值，此時就可以使用關鍵字 const 對變數的型別加以限定，
初始化和const
??因為const物件一旦創建后其值就不能再改變，所以const物件必須初始化，一如既往，初始值可以是任意復雜的運算式：
const int i = get_size();//正確：運行時初始化
const int j = 42;//正確：編譯時初始化
const int k;//錯誤：k是一個未經初始化的常量
??正如之前反復提到的，物件的型別決定了其上的操作，與非const型別所能參與的操作相比，const型別的物件能完成其中大部分，但也不是所有的操作都適合，主要的限制就是只能在const型別的物件上執行不改變其內容的操作，例如，const int和普通的int一樣都能參與算術運算，也都能轉換成一個布林值，等等 ，
在不改變const物件的操作中還有一種是初始化，如果利用一個物件去初始化另外 一個物件，則它們是不是const都無關緊要：
int i = 42;
const int ci = i;//正確： 1的值被拷貝給了ci
int j = ci;//正確：ci的值被拷貝給了J
默認狀態下，const物件僅在檔案內有效
??當以編譯時 初始化的方式定義 一個const物件時，就如對bufSize的定義 一樣：
const int bufSize = 512;//輸入緩沖區大小
??編譯器將在編譯程序中把用到該變數的地方都替換成對應的值，也就是說，編譯器會找到代碼中所有用到 bufSize的地方，然后用512替換，為了執行上述替換，編譯器必須知道變數的初始值 ，如果程式包含多個檔案，則每個 用了const物件的 檔案都必須得能訪問到它的初始值才行，要做到這一點，就必須在每 一個用到變數的檔案中都有對它的定義（參見C++Primer2.2.2節，第41頁），為了支持這一用法， 同時避免對同一變數的重復定義，默認情況下，const物件被設定為僅在檔案內有效，當多個檔案中出現了同名的const變數時，其實等同于在不同檔案中分別定義了獨立的變數，
??某些時候有這樣一種const變數，它的初始值不是一個常旦運算式，但又確實有必要在檔案間共享，這種情況下，我們不希望編譯器為每個檔案分別生成獨立的變數，相反，我們想讓這類const物件像其他（非常量）物件一樣作業，也就是說，只在一個檔案中 定義const，而在其他多個檔案中宣告并使用它，
??解決的辦法是，對于const變數不管是宣告還是定義都添加extern關鍵字，這樣只需定義一次就可以了：
//file_l.cc定義并初始化了一個常岳，該常量能被其他檔案訪問
extern const int bufSize =fen();
//file_l.h頭檔案
extern const int bufSize;//與file_l.cc中定義的bufSize是同一個
1.變數中的const
1.1 普通變數
直接在普通變數型別宣告符前加上 const，可以將其宣告為 const 型別：
const int a = 0;
這樣就把 a 宣告成了一個 const 型別的常量，所以我們不能再改變它的值了，所以下面試圖改變 a 的陳述句將會編譯報錯：
a = 10;
修改區域變數的值：
1.如果const修飾的區域變數是基礎的型別(int char double等等)，并且初始化使用字面常量的話，不會給該變數分配空間，
例如：
void test()
{
const int a = 10;//用字面常量10來初始化
a = 20;//error
}
2.但是，當我們對這個變數進行取地址的操作的時候，系統會為該變數分配空間，
void test()
{
const int a = 10;
//a = 20;//error
int* p = (int*)&a;
*p = 20;
cout << a << endl;
cout << *p << endl;
}
上面的結果是：10和20
??這是因為，當我們定義一個被const修飾并且使用字面常量來初始化的區域變數的時候，系統會把這個變數看作是一個符號，放入到符號表中，這么變數名就是一個符號，值就是這個符號的值，類似于#define的作用，(這就是 C++ 中的常量折疊 ，因為常量是在運行時初始化的，編譯器對常量進行優化，直接將常量值放在編譯器的符號表中，使用常量時直接從符號表中取出常量的值，省去了訪存這一步驟，)
??當我們對這個變數取地址的時候，由于原來沒有空間，就沒有地址，現在需要取地址，所以才被迫分配一塊空間，我們通過地址的解參考可以修改這個空間的值，這也就是為什么第二個結果為20的原因，但是如果我們還是通過變數名來訪問資料的話，系統會認為這還是一個符號，直接用符號表里面的值替換，
但是！
3.如果初始化不是用字面常量而是用變數，那么系統會直接分配空間，
void test()
{
int b = 20;
const int a = b;
}
這時候的a是有空間的，不會被放入到符號表中，
修改全域變數的值
??通過指標修改位于靜態存盤區的的const變數，語法上沒有報錯，編譯不會出錯，一旦運行就會報告例外，因為全域變數存盤于靜態存盤區，靜態存盤區中的常量只有讀權限，不能修改它的值，
??與C一樣，當const修飾普通的全域變數的時候，不能通過變數名和地址來修改變數的值，
另外
??與C不一樣的是，C語言中的const修飾的普通全域變數默認是外部鏈接屬性的，但是在C++中被const修飾的普通全域變數是內部鏈接屬性的，
??也就是說當我們在一個檔案中定義了一個如下的全域變數
const int a = 10;//定義全域變數
int main()
{
return 0;
}
??我們在另外一個檔案中，使用extern來宣告，也是不可以的，
//另外一個檔案
extern const int a;//在另外的檔案中宣告
??上面這種做法是不可以的，C++中被const修飾的全域變數默認是內部鏈接屬性，不能直接在另外的檔案中使用，如果想要在另外的檔案中使用，就需要在定義該全域的變數的檔案中用extern來修飾(另一個檔案也需要extern修飾)，
//定義的檔案
extern const int a = 10;
//另外一個檔案宣告
extern const int a;
原文鏈接：https://blog.csdn.net/weixin_61021362/article/details/121544469
1.2 const 修飾參考
??我們還可以對參考使用 const 限定符，在參考宣告的型別宣告符前加上 const 就可以宣告對const的參考，常量參考不能用來修改它所系結的物件，
參考系結到同一種型別，并修改值
直接上例子：
int i = 0;
const int j = 0;
const int &r1 = i;
//r1 = 20;//err不能給常量賦值
const int &r2 = j;
//r2 = 20;//err不能給常量賦值
int &r3 = j;
??第三行將非常量物件 i 系結到 const 參考 r1 上，此程序中發生了隱式型別轉換，i 的型別為 int，r1 的型別為 const int &， 所以這個程序 i 就從 int 轉換為了 const int，所以不能通過 r1 改變 i 的值，但可以直接改變 i 的值，但是 const int 型別不能轉換為 int，
可以這樣理解：const int是int的一種，但是范圍更小，將int限定在一個范圍之類，(本身int = const int型別 + 非const型別)，沒有問題，但是const int到int范圍擴大，超出權限，
??第五行將常量物件 j 系結到 const 參考 r2 上，不能直接改變 j 的值也不能通過常量參考改變 j 的值，
??第七行將常量物件系結到 const 參考 r3 上，報錯，不能將常量物件系結到常量參考上，
系結到另一種型別，并修改值
直接上例子：
double i= 1.0;
const int &r1 = i;
i = 2.0;
cout << "i = " << i << endl;
cout << "r1 = " << r1 <<endl;
---------------------------------------
out:
i = 2;
r1 = 1;
??上面的代碼將 int 型的參考 r1 系結到 double 型變數 i 上，然后改變 i 的值，我們發現 r1 并沒有改變，它的值反而是系結 i 時 i 的值，這是因為參考變數的型別與被參考物件的型別不同時，中間會有如下操作：
double i = 1.0;
int temp = i;
const int &r1 = temp;
??r1 參考的是臨時量 temp，而不是 i，所以才會出現上面的情況，
1.3 const 修飾指標
??當使用const修飾指標變數時，情況就復雜起來了，const可以放置在不同的地方，因此具有不同的含義，來看下面一個例子：
int age = 39;
const int * p1 = &age;
int const * p2 = &age;
int * const p3 = &age;
const int * const p4 = &age;
??二三行是一個意思，表示 p 是指向常量的指標；第四行表示 p 是常量指標；第五行表示 p 是指向常量的常量指標，
??上面二三行的賦值同樣發生了型別轉換，從 int * 轉換為 const int *，
指向常量的指標和常量指標
顧名思義：常量指標就是指標本身是常量，指標的值不能改變，也就是指標不能改變指向的物件，所以常量指標必須初始化；
指向常量的指標就是指向的變數時常量，被指變數不能被修改，
也可以將兩者結合，就有了指向常量的常量指標，其具有指向常量的指標和常量指標的共同性質，
修改指向常量的指標和常量指標
int age2 = 20;
*p1 = 20;
*p3 = 20;
p1 = &age2;
p3 = &age2;
??第二行會報錯，因為 p1 是指向常量的指標，不能通過指標修改 age 的值；第五行會報錯，因為 p3 是常量指標，只能指向 age，不能指向其他變數，
??如果對age2進行修改是不會報錯的，
原文鏈接：https://blog.csdn.net/weixin_45773137/article/details/126297568
1.4頂層與底層const
??任意常量物件為頂層const，包括常量指標；指向常量的指標和宣告const的參考都為底層const
??頂層const（top-level const）表示指標本身是個常量 int* const ptr=&m；
??此時指標不可以發生改變，但是指標所指向的物件值是可以改變的
??底層const（low-level const）表示指標所指的物件是常量 const int* ptr=&m；
??此時指標可以發生改變，但是指標所指向的物件值是不可以改變的
??頂層const可以表示任意的物件是常量（指標、參考、int、double都可以）
??于是只有指標和參考等復合型別可以是底層const
??執行物件的拷貝構造時，常量是頂層const還是底層const差別明顯
??頂層const并不會有任何影響
進行拷貝操作的時候，僅僅只是從右值（頂層const）拷貝一個值并給自己賦值，雖然右值是一個不可變的量，但是貌似對我自己的拷貝完全沒有影響吧
const int m = 10;
int n = m;
int* const ptr2 = &n;
int* ptr3 = ptr2;
int i= 0;
int *const p1 = &i;//不能改變p1的值，這是一個頂層const
const int ci = 42;//不能改變ci的值，這是一個頂層const
const int *p2 = &ci;//允許改變p2的值 這是一個底層const
const int *const p3 = p2;//靠右的const是頂層const, 靠左的是底層
const const int &r = ci;//用于宣告參考的const都是底層const
??當執行物件的拷貝操作時， 常量是頂層const還是底層const區別明顯， 其中，頂層const不受什么影響：
i = ci;//正確：拷貝ci的值，CI是 一個頂層const, 對此操作無影響
p2 = p3;//正確：p2和p3指向的物件型別相同，p3頂層const的部分不影響
??執行拷貝操作并不會改變被拷貝物件的值，因此，拷入和拷出的物件是否是常量都沒什么 影響，
??另一方面，底層const的限制卻不能忽視， 當執行物件的拷貝操作時拷入和拷出的物件必須具有相同的底層const資格， 或者兩個物件的資料型別必須能夠轉換，非常量可以轉換成常扯， 反之則不行：
int *p = p3;//錯誤：p3包含底層const的定義，而p沒有
p2 = p3;//正確：p2和p3都是底層const
p2 = &i;//正確：int*能轉換成const int*
int &r = ci;//錯誤：普通的int&不能系結到int常量上
const int &r2 = 1;//正確：const int&可以系結到一個普通int上
??p3既是頂層const也是底層const，拷貝p3時可以不在乎它是一個頂層const，但是必須清楚它指向的物件得是一個常量，因此，不能用p3去初始化p， 因為p指向的是一 個普通的（非常量）整數， 另一方面，p3的值可以賦給p2，是因為這兩個指標都是底層 const，盡管p3同時也是一個常量指標（頂層const)， 僅就這次賦值而言不會有什么影響，
原文鏈接：https://blog.csdn.net/m0_64860543/article/details/128269607
2.const 函式形參
??我們已經了解了變數中const修飾符的作用，呼叫函式就會涉及變數引數的問題，那么在形參串列中const形參與非const形參有什么區別呢？
2.1 const 修飾普通形參
同樣，先來看看普通變數：
void fun(const int i)
{
i = 0;
cout << i << endl;
}
void fun(int i)
{
i = 0;
cout << i << endl;
}
int main()
{
const int i = 1;
fun(i);
return 0;
}
??形參的頂層 const 在初始化時會被忽略，所以上面定義的兩個函式實際上是一個函式，編譯時會出現void fun(int) previously defined here錯誤，
-
由于普通變數是拷貝傳值，所以const int實參可以傳給 int 形參，
-
與普通 const 變數一樣，第一個 fun 中的形參 i 只可讀；第二個function中的 i 則可讀可寫，
2.2 const 修飾指標形參
??與 const 指標變數一樣，指向常量的指標形參指向的值不能修改；常量指標形參不能指向其他變數；指向常量的常量指標形參指向的值不能被修改，也不能指向其他變數，
#include<iostream>
using namespace std;
void fun(const int* i)
{
cout << *i << endl;
}
void fun(int* i)
{
*i = 0;
cout << *i << endl;
}
int main()
{
const int i = 1;
//呼叫 fun(const int* i)，沒有 fun(const int* i)，則會編譯報錯，因為沒有匹配形參的函式，
fun(&i);
int j = 1;
//呼叫 fun(int* i)，沒有 fun(int* i)，則會呼叫 fun(const int* i)，此時 j 的值不會被改變
fun(&j);
return 0;
}
??p1 指向的值不能修改；p2 不能指向其他變數；p3 指向的值不能被修改，也不能指向其他變數，
此外，形參的底層 const 在初始化時不會被忽略，所以上面的兩個函式是不同的函式，即多載函式，上面例子編譯并不會報錯，若果再加上一個void fun(int *const i)就會報錯，因為這個函式定義里面 i 是頂層 const，
2.3 const 修飾參考形參
??與 const 參考一樣，const 參考不會改變被參考變數的值，
#include<iostream>
using namespace std;
void fun(const int& i)
{
cout << i << endl;
}
void fun(int& i)
{
i = 0;
cout << i << endl;
}
int main()
{
const int i = 1;
//呼叫 fun(const int& i)，沒有 fun(const int& i)，則會編譯報錯，因為沒有匹配形參的函式，
fun(i);
int j = 1;
//呼叫 fun(int& i)，沒有 fun(int& i)，則會呼叫 fun(const int& i)，此時 j 的值不會被改變
fun(j);
return 0;
}
由于 const 參考也是底層 const ，所以上面兩個函式是不同的函式，即多載函式，編譯并不會報錯，
3.類常量成員函式
??面向物件程式設計中，為了體現封裝性，通常不允許直接修改類物件的資料成員，若要修改類物件，應呼叫公有成員函式來完成，為了保證const物件的常量性，編譯器須區分試圖修改類物件與不修改類物件的函式，例如：
const Screen blankScreen;
blankScreen.display(); // 物件的讀操作
blankScreen.set(‘*’); // 錯誤：const類物件不允許修改
??C++中的常量物件，以及常量物件的指標或參考都只能呼叫常量成員函式，
??要宣告一個const型別的類成員函式，只需要在成員函式引數串列后加上關鍵字const，例如：
class Screen
{
public:
char get() const;
};
在類外定義const成員函式時，還必須加上const關鍵字：
char Screen::get() const
{
return screen[cursor];
}
若將成員成員函式宣告為const，則該函式不允許修改類的資料成員，例如：
class Screen
{
public:
int get_cursor() const {return cursor; }
int set_cursor(int intival) const { cursor = intival; }
};
在上面成員函式的定義中，get_cursor()的定義是合法的，set_cursor()的定義則非法，
值得注意的是，把一個成員函式宣告為const可以保證這個成員函式不修改資料成員，但是，如果據成員是指標，則const成員函式并不能保證不修改指標指向的物件，編譯器不會把這種修改檢測為錯誤，例如:
class Name
{
public:
void setName(const string &s) const;
char *getName() const;
private:
char *m_sName;
};
void setName(const string &s) const
{
m_sName = s.c_str(); // 錯誤！不能修改m_sName;
for (int i = 0; i < s.size(); ++i)
m_sName[i] = s[i]; // 不是錯誤的
}
const成員函式可以被具有相同引數串列的非const成員函式多載，例如:
class Screen
{
public:
char get(int x,int y);
char get(int x,int y) const;
};
在這種情況下，類物件的常量性決定呼叫哪個函式，
const Screen cs;
Screen cc2;
char ch = cs.get(0, 0); // 呼叫const成員函式
ch = cs2.get(0, 0); // 呼叫非const成員函式
const成員函式不能修改類物件資料成員的深層決議：
呼叫成員函式時，通過一個名為this的隱式引數來訪問呼叫該函式的物件成員，例如：
Name bozai;
bozai.setName("bozai");
bozai.getName("BOZAI");
原文鏈接：https://blog.csdn.net/weixin_45773137/article/details/126297568
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/547130.html
標籤：其他