C++ const總結
編程中是否遇到這樣情況？
(基本內容來源於C++ Prime)
1、用一個變量表示緩衝區的大小。當我們覺得不合適時，直接改變變量值即可，可以很方便調整緩衝區大小
2、但要警惕程序不小心改變了這個值
OK，遇到這樣情況，使用const修飾符即可。
言簡意賅，總結一下。
首先上目錄：
1、const對象必須初始化。
2、默認情況下，cosnt對象只在文件內有效
3、const的引用
4、const與指針
5、頂層const 和 底層const
6、C++常量摺疊
7、const函數
8、const成員變量
1、const對象必須初始化。
因爲const對象一旦創建，就不能改變了。
2、默認情況下，cosnt對象只在文件內有效
下面論述一下const對象和普通對象的區別。
（轉載於http://blog.csdn.net/yipiantiandi/article/details/5822564）
（const對象默認作用域爲：文件作用域）
（普通變量默認作用域：整個程序）
對於一般的對象 如 int a=9；；我們知道它的作用域是整個程序的，在1.cpp和2.cpp中包含同一個定義了int a=9；的頭文件，因爲int a=9；作用域是整個程序，所以會產生錯誤。
那爲什麼const int a=9；不會產生錯誤呢。原因就是const int a=9；的默認作用範圍是文件作用域的。即，儘管在1.cpp和2.cpp中包含同一個定義了const int a=9；的頭文件，但由於const int a=9；是文件作用域的，包含了頭文件的1.cpp和2.cpp儘管都包含了const int a=9；但他們是各自文件內的const對象，兩者互不相干，就像不同函數中定義了相同的變量名一樣。
所以，通過在頭文件中定義const對象，可以實現多個文件使用相同的常量值，這在實際的程序中很常見。
那麼如何使用其他文件中的const
說到這裏，有一點疑問需要解決：如果想在別的文件中訪問本文件中的const對象該怎麼辦，如果都是單是在別的文件中使用extern const int a = 9;的話，不會起任何作用，因爲已經提示const int a = 9；是文件作用域的。
所以應該在需要被其他文件使用的const對象定義成這樣：extern const int a = 9;而在別的需要使用這個const對象的地方聲明：extern const int a;前者是定義，後者是聲明。這樣就可以使用了。
3、const的引用
| 引用前帶const修飾符 | 被引用前帶const修飾符 | 附註 |
| 是 | 是 | 對const變量的const引用 |
| 是 | 否 | 引用認爲它引用的變量不可以改變，但實際可以（代碼附註1） |
| 否 | 是 | 不可以（代碼附註2） |
| 否 | 否 | 就是普通的引用 |
代碼附註1：
int i=42; const int &r_i = i; cout<<"r_i: "<<r_i<<endl; cout<<"i: "<<i<<endl; i=41;//可以 cout<<"r_i: "<<r_i<<endl; cout<<"i: "<<i<<endl; r_i = 40;//報錯 cout<<"r_i: "<<r_i<<endl; cout<<"i: "<<i<<endl;
detail it:對const的引用可能是引用一個並非const的對象
常量引用僅對引用可以參與的操作做出了限定，對於引用的對象本身是不是常量未做限定。因爲對象也可能是一個非常量，所以允許通過其他途徑改變它的值。
代碼附註2
const int r1=42; int &r2 = r1;//試圖讓一個非常量引用指向一個常量對象。如果該初始化合法，則可以通過r2來改變它引用對象的值，這顯然不正確。
4、const與指針
| 指針 | 被指數據 | 附註 |
| 變量 | 變量 | 普通的指針 |
| 變量 | 常量 | 不可以 |
| 常量 | 變量 | 可以。常量指針“自以爲是”，認爲自己指向了常量，所以自覺的不去改變所指對象的值。實際上，這個值是可以改變的 |
| 常量 | 常量 | 可以。 |
| Pointer to Constant (常量指針/常指針) | Pointer Constant(指針常量) |
|
const int*p1; const int x = 1; p1 = &x; |
int*const p2 = &x; |
|
p1是一個指針 它是一個常量 |
p2是一個指針 它指向一個常量 |
| 準則：在前先讀，在前不變 | const int *x | int* const y |
|
* （指針）和const（常量）誰在前先讀誰； * 代表被指的數據，名字代表指針地址 const在誰前面誰就不允許改變。 |
const在*前面，該數據不能改變 | const在地址前面，該地址不能變化 |
（此小節內容來自網易公開課，北京郵電大學，崔毅東老師的《C++程序設計入門(上)》）
5、由上一節的內容，可以引申出一個概念：
頂層const 和 底層const
該對象是const，說明其爲頂層const
該對象指向或者引用的變量是const,說明其爲底層const
const int ci = 42; // 不能改變 ci 的值，這是一個頂層 const
const int *p2 = &ci; // 允許改變 p2 的值，這是一個底層 const
const int *const p3 = p2; // 靠右的 const 是頂層 const ，靠左的是底層 const
6、C++常量摺疊
常量與宏定義一直被面試官津津樂道
轉載於http://blog.csdn.net/yby4769250/article/details/7359278
看個code先，
#define PI 3.14 int main() { const int r = 10; int p = pI; //這裏會在預編譯階段產生宏替換，PI直接替換爲3.14，其實就是int p = 3.14; int len = 2*r; //這裏會發生常量摺疊，也就是對常量r的引用會替換成他對應的值，相當於int len = 2*10; return 0; }
如上述代碼中所述，常量摺疊表面上的效果和宏替換是一樣的，只是，“效果上是一樣的”，
而兩者真正的區別在於，
1、宏是字符常量，在預編譯完宏替換完成後，該宏名字會消失，所有對宏如PI的引用已經全部被替換爲它所對應的值，編譯器當然沒有必要再維護這個符號。
2、而常量摺疊發生的情況是，對常量的引用全部替換爲該常量如r的值，但是，常量名r並不會消失，編譯器會把他放入到符號表中，同時，會爲該變量分配空間，棧空間或者全局空間
爲了能更清楚的體現出常量摺疊，下面做幾個對照實驗，看代碼和輸出便了然：
int main() { int i0 = 11; const int i=0; //定義常量i int *j = (int *) &i; //看到這裏能對i進行取值，判斷i必然後自己的內存空間 //請注意，int *j = &i;是不對的哦，我們在第4節講過~
*j=1; //對j指向的內存進行修改 printf("%d\n%d\n%d\n%d\n",&i,j,i,*j); //觀看實驗效果 const int ck = 9; //這個對照實驗是爲了觀察，對常量ck的引用時，會產生的效果 int ik = ck; int i1 = 5; //這個對照實驗是爲了區別，對常量和變量的引用有什麼區別 int i2 = i1; return 0; }
上面的代碼會輸出：
0012ff7c
0012ff7c
0
1
這能說明什麼，至少能說明兩點：
1、i和j地址相同，指向同一塊空間，i雖然是可摺疊常量，但是，i確實有自己的空間
2、i和j指向同一塊內存，但是*j = 1對內存進行修改後，按道理來說，*j==1,i也應該等於1，而實驗結果確實i實實在在的等於0，這是爲什麼呢，就是本文所說的內容，i是可摺疊常量，在編譯階段對i的引用已經別替換爲i的值了，也就是說
printf("%d\n%d\n%d\n%d\n",&i,j,i,*j)
中的i已經被替換，其實已經被改爲
printf("%d\n%d\n%d\n%d\n",&i,j,0,*j)
爲了使實驗更具說服力，直接上彙編代碼，比較實驗的不同點：
4: int main() 5: { 00401030 push ebp 00401031 mov ebp,esp 00401033 sub esp,5Ch 00401036 push ebx 00401037 push esi 00401038 push edi 00401039 lea edi,[ebp-5Ch] 0040103C mov ecx,17h 00401041 mov eax,0CCCCCCCCh 00401046 rep stos dword ptr [edi] 6: int i0 = 11; 00401048 mov dword ptr [ebp-4],0Bh 7: 8: const int i=0; 0040104F mov dword ptr [ebp-8],0 //睜大眼睛，編譯器確實爲常量i分配了棧空間，並賦值爲0 9: int *j = (int *) &i; 00401056 lea eax,[ebp-8] 00401059 mov dword ptr [ebp-0Ch],eax 10: *j=1; 0040105C mov ecx,dword ptr [ebp-0Ch] 0040105F mov dword ptr [ecx],1 11: //再看看下面的對比實驗，看出對常量的引用和變量的引用的區別 12: const int ck = 9; 00401065 mov dword ptr [ebp-10h],9 //爲常量分配棧空間 13: int ik = ck; 0040106C mov dword ptr [ebp-14h],9 //看到否，對常量ck的引用，會直接替換爲常量的值9，再看下面的實驗 14: 15: int i1 = 5; 00401073 mov dword ptr [ebp-18h],5 16: int i2 = i1; //這裏引用變量i1，對i2進行賦值，然後看到否，對常量i1引用沒有替換成i1的值，而是去棧中先取出i1的值，到edx寄存器中，然後再把值mov到i2所在的內存中 0040107A mov edx,dword ptr [ebp-18h] 0040107D mov dword ptr [ebp-1Ch],edx 17: 18: 19: return 0; 00401080 xor eax,eax 20: 21: }
總結：常量摺疊說的是，在編譯階段，對該變量進行值替換，同時，該常量擁有自己的內存空間，並非像宏定義一樣不分配空間，需澄清這點
7、const修飾函數
const 放在函數後表示這個函數是常成員函數, 常成員函數是不能改變成員變量值的函數。
const 限定符，它把一個對象轉換成一個常量。
1、非常量成員函數不能被常量成員對象調用，因爲它可能企圖修改常量的數據成員：
2、非常量成員函數不能被常量實例調用，因爲它可能企圖修改常量的數據成員：
爲了使成員函數的意義更加清楚，我們可在不改變對象的成員函數的函數原型中加上const說明：
class Point
{
public:
int GetX() const;
int GetY() const;
void SetPt (int, int);
void OffsetPt (int, int);
private:
int xVal, yVal;
};
const成員函數應該在函數原型說明和函數定義中都增加const限定：
int Point::GetY() const
{
return yVal;
}
class Set {
public:
Set (void){ card = 0; }
bool Member(const int) const;
void AddElem(const int);
};
bool Set::Member (const int elem) const
{
}
非常量成員函數不能被常量成員對象調用，因爲它可能企圖修改常量的數據成員：
const Set s;
s.AddElem(10); // 非法: AddElem不是常量成員函數
s.Member(10); // 正確
#include <iostream> using namespace std; class A { public: A(int size) : SIZE(size) {}; private: const int SIZE; }; int main() { A a(100); }
- 在類中聲明變量爲const類型，但是不可以初始化
- const常量的初始化必須在構造函數初始化列表中初始化，而不可以在構造函數函數體內初始化
此時的const變量屬於具體的一個對象，如何在整個類中都恆定不變呢？
答案是利用枚舉，舉例
#include <iostream> using namespace std; class A { private: enum {SIZE = 100}; public: int array[SIZE]; }; int main() { A a; }