零、文章來由

打算將基礎知識在看書的同時系統的整理一下，方便大家也方便自己。整理的知識儘量參照書本知識，比網上獲取的資料有更高的可信度。

一、從 文字常量和常變數 開始

1、文字常量

程式中的特殊識別符號或表示式，由於同時滿足：
（1）不可定址（放在程式碼區）
（2）值不可變
所以可視為文字常量。他們是 靜態陣列名、列舉變數、全域性（靜態變數）首地址、#define定義的常量。

整型文字常量：
（1）前加0表示 八進位制
（2）前加0x表示 十六進位制
（3）後加L（推薦）或l，表示long型別
（4）後加U（或u）表示無符號數

eg.1024UL

2、常變數Const

同其他變數一樣被分配空間，可定址。

const是在高階語言的語義層面上定義的，是編譯器在編譯期做語法檢測來保證，但是執行時，const變數不是在只讀記憶體中，而是和一般變數一樣放在資料區，所以一樣可以對其進行修改。

所以：常變數是一種加了特殊限制的變數，理解成“只讀”變數

即使是const修飾，也是可以修改的

#include <iostream>
using namespace std;

void ShowValue(const int &i) {
    cout<<i<<endl;
}

int main() 
{
    const
 
 int j=5;
    void *p=(void *)&j;
    int *ptr=(int *)p;
    (*ptr)++;
    //cout<<j<<endl; //還是會顯示5，因為編譯器優化的時候將j替換為文字常量5
    //但如果是int i=5; const int j=i; 則無法替換，直接輸出j為6
    ShowValue(j); //顯示6

    return 0; 
}

或：

#include <iostream>
using namespace std;

void ShowValue(const int &i) {
    cout
 
<<i<<endl;
}

int main(int argc,char *argv[])
{
    int tmp = 5;
    const int & aa =tmp;
    ShowValue(++(*((int *)&aa))); //顯示6

    return 0; 
}

3、常變數替換

如果常變數有初始化賦初值，那編譯器將該常變數在其他地方替換成文字常量
但是如果開始不初始化就會錯誤

如：

void DefineArray(const int n){
     int B[n]={}; //error,陣列大小在編譯期確定
}

int main(){
     const int m=5;
     int A[m]={}; //ok
}

4、文字常量和常變數定址

int &r=5; //error，無法定址文字常量，無法建立引用

const int &r=5; //ok，在資料區開闢一個值為5的無名整數量，然後將引用r與這個整形兩繫結

二、const用法

1、const的位置

int const *p; //指向常量的指標（即常指標，const修飾的是int），指向的物件是const型，不可以修改，但是指標p的指向可以修改
int *const p; //指標常量（const修飾的是int*），指標變數p是const型，它的指向不可修改，但是指向的物件可以修改

const和資料型別結合在一起 —>“常型別”。（看成一個整體）

修飾型別時，既可以放在放前面，也可以放在後面；用常型別宣告 or 定義變數，const只出現在變數前。

const和被修飾型別間不能有其他識別符號存在。

引用本身可以理解成一個指標常量

故在引用前使用const沒有意義

int & const r4=i; //const是多餘的，編譯器warning後忽略const存在

const配合二重指標，此例子中const在不同位置，結果不同

#include <iostream>
using namespace std;

int main() 
{
    int const **p1; //不是指標常量，指向 int count*（“int const*”是一個 指向整型常量的指標）
    int *const *p2; //不是指標常量，但所指的變數是指標常量（int *const，即指向整型的指標常量，指向不能修改）

    int i=5;
    int j=6;

    const int *ptr1=&i;
    int *const ptr2=&j;

    p1=&ptr1;
    p2=&ptr2;

    cout<<**p1<<endl;
    cout<<**p2<<endl;

    return 0; 
}

輸出：
5
6

上述p1和p2 賦值有講究，如果 p1=&ptr2 或 p2=ptr1 就會編譯錯誤

2、const修飾某個類 —> 常物件 和 常函式

const修飾物件–>常物件
const修飾成員函式—>常函式

在常函式中，不允許對任何成員變數進行修改

通過常物件，只能呼叫該物件的常函式

#include <iostream>
using namespace std;

class A
{
    int num;
public:
    A() {num=5;}
    void disp();
    void disp() const;
    void set(int n) {num=n;}

};

void A::disp() const {
    cout<<num<<endl;
}

void A::disp() {
    cout<<"non-const version of disp()"<<endl;
}

int main() 
{
    A a1;
    a1.set(3);
    a1.disp();
    A const a2;
    a2.disp();
}

以上注意：
（1）如果常函式宣告和定義分開，都需要加const，否則編譯錯誤

只有類的非靜態成員函式可以被宣告為常函式

（2）如果一個類的兩個成員函式，返回值、函式名、引數列表完全相同，其中之一是const，則過載。因為 常成員函式的引數傳入this指標是const Class*型別的，引數不同，導致函式簽名不同。

非只讀物件（如a1）呼叫某個函式（如 disp()），先找非const版本，如果沒有，再呼叫const版本。而常物件，只能呼叫類中定義的常函式，否則編譯器報錯。

如果一個非const物件（如a1）呼叫函式，同時有const和非const版本的函式，我們希望其呼叫const函式。就必須建立該物件的常引用，或指向該物件的常指標來達到目的。如： (const A&)a1.disp(); 或 (const A *)&a1->disp();

（3）常物件建立後，其資料成員不允許在修改。所以顯示建構函式來初始化該物件非常重要。

常物件，全體成員資料成員都是常量看待。
類物件的非靜態常量成員必須在建構函式中初始化，且只能藉助初始化列表進行。

3、const修飾函式引數+函式返回值

#include <iostream>
using namespace std;

void disp1(const int &ri){
    cout<<ri<<endl;
}

void disp2(const int i){
    cout<<i<<endl;
}

const int disp3(const int& ri){
    cout<<ri<<endl;
    return ri;
}

int& disp4(int& ri){
    cout<<ri<<endl;
    return ri;
}

const int& disp5(int& ri){
    cout<<ri<<endl;
    return ri;
}


int main(int argc,char* argv[])
{
    int n=5;
    disp1(n);
    disp2(n);
    disp3(n);
    disp4(n)=6; //修改引用返回值
    disp5(n);//disp5(n)=6;是錯誤的
}

注意：
（1）const修飾引數，主要作用是被引用物件或被指向物件，如果只是形參，就沒有多少意義。如：void disp2(const int i)，這裡的i在函式中改不改變，加不加const沒什麼影響。

不但如此，同時定義一個相似的用const修飾引數和不用const修飾引數的函式，會引起重定義錯誤。比如：任何整型表示式的值，都可以傳給int型參變數，也可以傳給const int型參變數，故不過載。

（2）當返回值是一個普通資料，而非引用，const修飾也沒多少意義。因為函式返回值是一個非左值，本來就不能改變其值。故其上 const int disp3(const int& ri)，對返回值修飾然並卵。

（3）如果返回值為引用，用const修飾可以阻止對被引用物件修改，disp5(n)=6;是錯誤的

（4）常見的對const的誤解。

誤解一：用const修改的變數值一定是不能改變的。const修飾的變數可通過指標可間接修改。

如：

const int j=5;
void *p=(void *)&j;
int *ptr=(int *)p;
(*ptr)++;

誤解二：常引用或常指標，只能指向常變數，這是一個極大的誤解。常引用或者常指標只能說明不能通過該引用（或者該指標）去修改被引用的物件，至於被引用物件原來是什麼性質是無法由常引用（常指標）決定的。

三、const_cast 的用法

1、作用

const_cast 是 C++ 運算子，作用是去除符合型別中的const或者volatile

當大量使用const_cast是不明智的，只能說程式存在設計缺陷。使用方法見下例：

void constTest(){
    int i;
    cout<<"please input a integer:";
    cin>>i;
    const int a=i;
    int& r=const_cast<int&>(a);//若寫成int& r=a;則發生編譯錯誤
    ++r;
    cout<<a<<endl;
}
int main(int argc,char* argv[])
{
    constTest();
    return 0;
}

輸入：
5

輸出：
6

總結：
（1）const_cast運算子的語法形式是const_cast< type> (expression)。 括號不可省略

（2）const_cast只能去除目標的const或者volatile屬性，不能進行不同型別的轉換。只能將 const type* 轉換為 type*，或者 const type & 轉換為 type &。
如下轉換就是錯誤的：

cons tint A={1,2,3}; 
char* p=const_cast< char*>(A); //不能由const int[]轉換為char* 

（3）一個變數被定義為只讀變數（常變數），那麼它永遠是常變數。cosnt_cast取消的是間接引用時的改寫限制，而不能改變變數本身的const屬性。 如下就是錯誤的：

int j = const_cast< int> (i);

（4）利用傳統的C語言中的強制型別轉換也可以將 const type* 型別轉換為 type* 型別，或者將 const type& 轉換為 type& 型別。但是使用 const_cast 會更好一些，因為 const_cast 寫法複雜（提醒程式猿不要輕易轉換），轉換能力較弱，目的明確，不易出錯，易查bug；而C風格的強制型別轉換能力太強，風險較大。

參考資料

[1]陳剛.C++高階進階教程[M].武漢：武漢大學出版社，2008.