const T、const T*、T *const、const T&、const T*& 的區別
阿新 • • 發佈：2019-02-04
這裡的T指的是一種資料型別，可以是int、long、doule等基本資料型別，也可以是自己型別的型別class。單獨的一個const你肯定知道指的是一個常量，但const與其他型別聯合起來的眾多變化，你是不是就糊塗了？下面我們一一來解析。
const T
定義一個常量，宣告的同時必須進行初始化。一旦宣告，這個值將不能被改變。
int i = 5;
const int constInt = 10; //正確
const int constInt2 = i; //正確
constInt = 20; //錯誤，常量值不可被改變
const int const T*
指向常量的指標，不能用於改變其所指向的物件的值。
const int i = 5;
const int i2 = 10;
const int* pInt = &i; //正確，指向一個const int物件，即i的地址
//*pInt = 10; //錯誤，不能改變其所指缶的物件
pInt = &i2; //正確，可以改變pInt指標本身的值,此時pInt指向的是i2的地址
const int* p2 = new const int* 與int* const的區別
指標本身就是一種物件，把指標定義為常量就是常量指標，也就是int* const的型別，也可以寫成int *const，宣告時必須初始化。
int nValue = 10;
int* const p = &nValue;
int *const p2 = &nValue;
const int* 指標指向的物件不可以改變，但指標本身的值可以改變；int* const 指標本身的值不可改變，但其指向的物件可以改變。
int nValue1 = 10;
int nValue2 = 20;
int* const constPoint = &nValue1;
//constPoint = & nValue2; //錯誤，不能改變constPoint本身的值
*constPoint = 40; //正確，可以改變constPoint所指向的物件，此時nValue1 = 40
const int nConstValue1 = 5;
const int nConstValue2 = 15;
const int* pPoint = &nConstValue1;
//*pPoint = 55; //錯誤，不能改變pPoint所指向物件的值
pPoint = &nConstValue2; //正確，可以改變pPoint指標本身的值，此時pPoint邦定的是nConstValue2物件，即pPoint為nConstValue2的地址const int* const 是一個指向常量物件的常量指標，即不可以改變指標本身的值，也不可以改變指標指向的物件。
const int nConstValue1 = 5;
const int nConstValue2 = 15;
const int* const pPoint = &nConstValue1;
//*pPoint = 55; //錯誤，不能改變pPoint所指向物件的值
//pPoint = &nConstValue2; //錯誤，不能改變pPoint本身的值const T&
對常量(const)的引用，又稱為常量引用，常量引用不能修改其邦定的物件。
int i = 5;
const int constInt = 10;
const int& rConstInt = constInt; //正確，引用及邦定的值都是常量
rConstInt = 5; //錯誤，不能改變引用所指向的物件允許為一個常量引用邦定一個非常量物件、字面值，甚至是表示式；引用的型別與引用所指向的型別必須一致。
int i = 5;
int& rInt = i; //正確，int的引用
const int constInt = 10;
const int& rConstInt = constInt; //正確，引用及邦定的值都是常量
const int& rConstInt2 = rInt; //正確，用rInt邦定的物件進行賦值
rInt = 30; //這時，rConstInt2、rInt、i的值都為30
//rConstInt2 = 30; //錯誤，rConstInt2是常量引用，rConstInt2本身不能改變所指向的物件
int i2 = 15;
const int& rConstInt3 = i2; //正確，用非常量的物件為其賦值
const int& rConstInt4 = i + i2; //正確，用表示式為其賦值,值為45
i = 20; //此時i=20, rInt = 20, rConstInt4 = 45,說明rConstInt4邦定的是i + i2的臨時變數
const int& rConstInt5 = 50; //正解，用一個常量值為其賦值const T*&與T *const&
指向常量物件的指標的引用，這可以分兩步來理解：1.const T*是指向常量的指標；2.const T*&指向常量的指標的引用。
const int nConstValue = 1; //常量物件
const int nConstValue2 = 2; //常量物件
const int* pConstValue = &nConstValue; //指向常量物件的指標
const int* pConstValue2 = &nConstValue2; //指向常量物件的指標
const int*& rpConstValue = pConstValue; //指向常量物件的指標的引用
//*rpConstValue = 10; //錯誤，rpConstValue指向的是常量物件，常量物件的值不可改變
rpConstValue = pConstValue2; //正確，此時pConstValue的值等於pConstValue2
//指向常量物件的指標本身是物件，引用可以改變邦定物件的值
int nValue = 5;
int nValue2 = 10;
int *const constPoint = &nValue; //常量指標
int *const constPoint2 = &nValue2; //常量指標
int *const &rpConstPoint = constPoint; //對常量指標的引用,邦定constPoint
//rpConstPoint = constPoint2; //錯誤，constPoint是常量指標，指標本身的值不可改變
*rpConstPoint = 20; //正確，指標指向的物件可以改變在函式中的應用
我們直接從需求出來，假設有這樣一個數據結構：
typedef struct __Data
{
int value;
public:
__Data()
:value(0){}
}Data;1.希望傳入一個物件，又不想讓函式體修改這個物件。
方式<1>
void Dealwith(const Data& data)
{
cout << data.value << endl;
//data.value = 5; //錯誤，data是常量引用，不能改變其邦定的物件
}這種方式還有一個好處是隻有在呼叫函式的時候會邦定物件，傳遞的是物件的引用，而不是物件，減少函式呼叫時物件賦值的花銷。
方式<2>
void Dealwith(const Data* pData)
{
cout << pData->value << endl;
//pData->value = 5; //錯誤，pData是指向常量物件的指標，不能改變其指向的物件
}這種方式與void Dealwith(const Data& data)的功能相同
方式<3>
Data g_data(20);
void Dealwith(const Data*& pData)
{
cout << pData->value << endl;
//pData->value = 5; //錯誤，pData邦定的是指向常量物件的指標，常量物件的指標不能改變其指向的物件
pData = &g_data; //正確，pData是[指向常量物件的指標]的引用，引用可改變其邦定的物件
}呼叫如下：
Data d(10);
const Data* pData = &d;
Dealwith(pData);
cout << pData->value << endl; //此時pData->value為20，d.value還是10這種方式函式未改變傳入的物件的值，但可以返回另外一個物件的指標。注意返回的指標必須指向全域性的物件，如果返回函式內定義的物件，退出函式作用域後，其指標將無效，這是非常危險的；如果Dealwith是成員函式，也可以返回指向成員的指標。
2.在類中的使用，返回一個類的成員，但不希望呼叫方修改這個成員。
方式<1>
class MyData
{
public :
MyData(std::string name, Data data)
{
m_name = name;
m_data = data;
}
const Data* GetData()
{
return &m_data;
}
private:
std::string m_name;
Data m_data;
};呼叫如下：
MyData mydata("", Data(100));
const Data* pData = mydata.GetData();
cout << pData->value << endl; //pData->value = 100
//pData->value = 50; //錯誤，pData是指向常量物件的指向，不能改變其指向物件的值 方式<2>
有人可能會問GetData也可以寫成這樣：
const Data& GetData()
{
return m_data;
}這樣的話，呼叫方常常容易寫成這樣：
MyData mydata("", Data(100));
Data data = mydata.GetData(); //這會有個賦值的過程，會把mydata.m_data賦給data
cout << data.value << endl; //data.value = 100
data.value = 50; //正確，data.value=50，但mydata.m_data.value還是100這樣呼叫時會有一個結果賦值的過程，如果Data是一個複雜的類，會有較大的開銷，其效果與下面這種方式是一樣的：
Data GetData()
{
return m_data;
}當然，如果呼叫方這樣使用是正確的：
const Data& GetData()
{
return m_data;
}MyData mydata("", Data(100));
const Data& data = mydata.GetData(); //這會有個賦值的過程，會把mydata.m_data賦給data
cout << data.value << endl; //data.value = 100
//data.value = 50; //錯誤，data是一個對常量的引用，不能改變其邦定的物件這對呼叫方的技術能力要求比較高，如果你是設計方，一定要儘量使介面簡單易用。
方式<3>
如果你要傳入一個Data進行一些處理，處理完後返回類的成員m_data，可如下實現：
void DoSomething(const Data*& pData)
{
if (pData != NULL)
{
// doto: 這裡實現你要處理的功能
}
pData = &m_data;
}如果您有什麼疑惑和想法，請在評論處給予反饋，您的反饋就是最好的測評師！由於本人技術和能力有限，如果本博文有錯誤或不足之處，敬請諒解並給出您寶貴的建議！
如果您有什麼疑惑和想法，請在評論處給予反饋，您的反饋就是最好的測評師！由於本人技術和能力有限，如果本博文有錯誤或不足之處，敬請諒解並給出您寶貴的建議！