const能夠增加程式的健壯型,減少程式出錯.const用法很多意義也不同。

基本的用法:
const int a =200; a的內容不變,a只能是200 ,也就是宣告一個int型別的常量(#define a 200)
int const s =200; //和上面作用一樣

const指標和引用一般用在函式的引數中
int* m = &a; //出錯,常量只能用常指標
int c= 1;

const int*pc = &c;//常指標可指向常量

const int* pa = &a; //指標指向的內容為常量
int const *a = &b; //指標指向的內容為常量*p=3//error
int* const a = &b; //指標為常量,不能更改指標瞭如 a++但可以改值*p=3;

從這可以看出const放在*左側修飾的是指標的內容,const放在*右側修飾的是指標本身.

const引用的用法和指標一樣
int const & a=b; 和指標一樣
const int& a=b; 和指標一樣
但沒有 int& const a=b 的用法因為引用不能做移位運算，但只是出個warning

const int* const a = &b; //綜合應用,一般用來傳遞多維的陣列
類如：char* init[] = {"Paris","in the","Spring"};
void fun(const int* const a){}
fun(init)//保護引數不被修改

int A(int)const; //是常函式，只能用在類中，呼叫它的物件不能改改變成員值
const int A(); //返回的是常量,所以必須這麼呼叫 cosnt int a=A();
int A(const int); //引數不能改值,可用在任意函式
int A(const int*);
....
int height() const;//常函式只能由常函式呼叫
int max(int,int) const;
int Max = max(height(),height());

const int* pHeap = new int;
delete pHeap;
p = NULL;//出錯
我的解決辦法是強制型別轉換
const int* pHeap = new int(1);
delete (int*)pHeap;
pHeap = NULL;

一、const 和引用聯合使用的時候要注意

const int a = 1;
const int& ref1 = a;
const int& ref2 = 1;

ref1 和 ref2 都是正確的，但是他們引用的內容和一般的引用不同
對 const int& ref1 = a; 而言，其實這個 ref1 已經和 a 沒有任何關係了
ref1 實際上是對一個臨時量的引用。同理 const int& ref2 = 1; 也是對
一個臨時量做的引用。當引用臨時量是 C++ 的隱式型別轉換可以起作用。
臨時量的生存期和引用量的生存期相同。

二、強傳const物件可能導致無定義行為

對於優化做的比較好的編譯器，程式碼 const int i = 1;
當後面用到變數 i 的時候，編譯器會優化掉對 i 的存取，而直接使用立即數 1

const int i = 1;

*(const_cast<int*>(&i)) = 2;
cout << *(int*)&i << endl;
cout << i << endl;

所以，對 const 物件做 const_cast 可能導致無定義行為

  
int height() const;//常函式只能由常函式呼叫
int max(int,int) const;
int Max = max(height(),height());

1.不能將const修飾的任何物件、引用和指標作為賦值表示式的左值。
const int cx=100;
const int & rcx=cx;
const int * pcx=&cx;
cx=200; //error
rcx=200; //error
*pcx=200; //error

2.const型別的物件不能直接被non-const型別的別名所引用。
(1)不能將const型別的物件傳遞給non-const型別的引用。
const int cx=100;
int & rx=cx; //error
(2)不能將const型別的實參傳遞給形參為non-const型別引用的函式。
void f(int a)
{
}
void g(int & ra)
{
}
const int cx=100;
f(cx); //ok
g(cx); //error
(3)不能將const型別的物件作為non-const型別引用的函式返回值。
int & f(const int & rca)
{
return rca; //error
}
int x=100;
f(x);

3.可以使用const類型別名引用non-const物件。此時通過const引用不能修改物件，但物件可以通過non-const引用被修改。
int x=100;
int & rx=x;
const int & rcx=x; //ok
x=200;
rx=200;
rcx=200; //error

4.指標的屬性有兩個：指標的型別和指標本身的常量性。其中，指向const物件與指向non-const物件，是不同的指標型別。
int x=100;
const int * pcx=&x; //[1]
int * px=&x; //[2]
int y=100;
int * const cpy=&y; //[3]
int * py=&y; //[4]
[1][2]兩個指標的型別不同；[3][4]兩個指標的常量性不同。
物件與指向物件的指標的規則類似於物件與引用。即，const型別的物件不能直接被non-const型別的指標所指示（同2）；可以使用const型別的指標指向non-const物件（同3）。

5.可以將相同型別（包括常量性）的const指標值賦給non-const指標。
int x=100;
int * px;
const int * pcx=&x;
px=pcx; //error
int * const cpx=&x;
px=cpx; //ok

6.若函式的返回值為內建型別或是指標，則該返回值自動成為const性質。但自定義型別則為non-const性質。
int f() //相當於返回const int
{
return 100;
}
int * g(int & ra) //相當於返回int * const
{
return &ra;
}
class CTest
{
int n;
public:
CTest(int n){this->n=n;}
};
CTest h() //返回的就是CTest
{
return CTest(200);
}

f()=200; //error

int x=100;
int y=200;
int * px=&x;
g(y)=px; //error
*g(y)=x; //ok，從這點可以看出g()返回的不是const int *

CTest t(100);
h()=t; //ok，但卻是完全錯誤的、危險的做法
//所以h()的正確寫法是返回const CTest

const int b=100; b的內容不變,b只能是100
int const b=100; b必須為int型,不能為其他型別?
這2句話的意思應該是一樣的吧 ， THINKING IN C++是這樣說的

 const int a=100; a的內容不變,a只能是100（同樣不能型別轉換）。
int const b=100; b必須為int型,不能為其他型別?（同樣在使用中不能修改）。
所以a和b是一樣的，稱為整型常數，在使用中不能被修改，當然都不能轉為其他型別了。
#include <iostream>

using namespace std;

int main()
{
　　const int a = 100;
　　int const b = 100;

　 a = 100; //這四條語句編譯時都會出現“Cannot modify a const object
b = 100; //in function main()”的錯誤提示，也就是說，任何企圖修改　　 a = 100.0;　//a和b（其實是一樣的）的行為都會出現“災難”，在語法上講就　　b = 100.0; //是a和b都不能出現在賦值語句的左邊！

　　cout<<'/n'<<a<<'/n'<<b<<endl;

　　return 0;
}

常函式的呼叫：常量物件只能呼叫常成員函式，非常量物件即可以調常成員函式，也可以調一般成員函式，但當某個函式有const和非const兩個版本時，const物件調const版本，非const物件調非const版本
例：
class A
{
public:
int & GetData(){return data;}
const int & GetData()const {return data;}
private:
int data;
}
A a;
a.GetData();//呼叫int & GetData(){return data;}
//但如果沒有這個函式，也可以呼叫const int & GetData()const
const A const_a;
const_a.GetData();//呼叫const int & GetData()const {return data;}
常函式只能調常函式，也是由於這個原因

一、const 和引用聯合使用的時候要注意

const int a = 1;
const int& ref1 = a;
const int& ref2 = 1;

ref1 和 ref2 都是正確的，但是他們引用的內容和一般的引用不同
對 const int& ref1 = a; 而言，其實這個 ref1 已經和 a 沒有任何關係了
ref1 實際上是對一個臨時量的引用。同理 const int& ref2 = 1; 也是對
一個臨時量做的引用。當引用臨時量是 C++ 的隱式型別轉換可以起作用。
臨時量的生存期和引用量的生存期相同。

二、強傳const物件可能導致無定義行為

對於優化做的比較好的編譯器，程式碼 const int i = 1;
當後面用到變數 i 的時候，編譯器會優化掉對 i 的存取，而直接使用立即數 1

const int i = 1;

*(const_cast<int*>(&i)) = 2;
cout << *(int*)&i << endl;
cout << i << endl;

所以，對 const 物件做 const_cast 可能導致無定義行為

#include <iostream.h>
void fun(char b){cout <<"void"<<endl;}
int fun(int const b){cout <<"int"<<endl;}
int main()
{
fun(1.0);//詳細看看過載函式吧
fun(4); //想一想呼叫哪一個

return 0;
}
我試了一下，會出錯? vc說：'fun':ambiguous call to overloaded function

const int i = 1;
*(const_cast<int*>(&i)) = 2;
cout << *(int*)&i << endl;
cout << i << endl;
這個可真有意思，除錯時兩個都是2，可編譯就是2，1了
const的永遠都是const,這樣能更改就不錯了，不然就自相矛盾了
奇怪的是 pi 和 &i地址一樣啊，就像樓上說的這是編譯時的優化
處理
const int i = 1;
int* pi=const_cast<int*>(&i);
*pi=2;
cout << *pi << endl;
cout << i << endl;

那個主要是隱式轉換
你可依次把兩個函式注掉看看呼叫
#include <iostream.h>
//void fun(char b){cout <<"void"<<endl;}
void fun(int b){cout <<"int"<<endl;}
int main()
{
fun('a');
fun(4);
return 0;
}

const
一.一般應用
1.const修飾各種變數的用法.
   a.取代define
     #define D_INT 100
     #define D_LONG 100.29
     ………
     const int D_INT = 100;
     const D_INT = 100;     //如果定義的int型別,可省略int.
     const long D_LONG = 100.29;
     ………
     const int& a = 100;
     const替代define雖然增加分配空間,可它卻保證了型別安全.
     在C標準中,const定義的資料相當於全域性的,而C++中視宣告的位置而定.
   b.修飾指標相關的變數
     以三組簡單的定義示意：
     Group1:  
     int a = 0;   
     const int* b = &a;------------  [1]               
     int const *b = &a;------------  [2]                    
     const int* const b = &a;---- [4]  
         
     Group2: 
     const char *p = "const";--------------[1]
     char const *p = "const";--------------[2]  
     char* const p = "const";--------------[3]  
     const char * const p = "const";----[4]     
    
     Group3:
      int a=0;
     const int &b = a;---------------[1]
     int const &b = a;---------------[2] 
     int & const b = a;--------------[3]  //--->修飾引用時,const被忽略
     const int & const b = a;-----[4]
     總結：
     1.如果const位於星號左側,則const用來修飾指標所指向的變數,
       即指標指向的為不可變的.
     2.如果const位於星號右側,const就是修飾指標本身,即指標本身是
       不可變的.
       因此,[1]和[2]的情況相同,指標所指向內容不可變(const放在變數
       宣告符的位置無關), 這種情況下不允許對內容進行更改,如不能*a = 3 ;
     3.[3]中指標本身是不可變的，而指標所指向的內容是可變的,這種情況
       下不能對指標本身進行更改操作,如a++是錯誤的
     4.[4]中指標本身和指向的內容均為常量.(引用特殊：引用在使用增加
       遇義時,增加它代表的變數.所以qualifiers on reference are ignoredv.
       延伸點:
       注意示例:
       1.const int& reference = 1000;
       2.char* p = "const"
         char*& q ;
  
2.const在函式環境下的各種應用
   常用法示例如下：
   const A&  _Fun(const  A& _in);  //修飾引用型傳入引數
   // A  _Fun(const A& _in);
   //A& _Fun(const A& _in);
   //上面的兩種,在函式內部有特殊的步驟,這裡不詳提了…..
 
   const  A*  _Fun( const  A* _in);   //修飾指標型傳入引數
   void _Fun( ) const;   //修飾class成員函式
   const  A&  _Fun(A& _in );  //修飾返回值
   const A & operator(const A& _in);  //同時修飾傳入引數和返回值

   a.修飾引數
     如void _Fun(const A* _in)或 void _Fun(const A& _in);
     它們被修飾後,在函式執行期間行為特性同於上面的講解,
     注意：這不會改變原來資料的是否是const的屬性.

   b.修飾函式返回值
    const A&  _Fun( )
    const A*   _Fun( );
    注意：由於生命期不同步的問題,不可將區域性的變數的指標或引用返回(static除外).
    另外,傳出來的視情況,代表不同的意思…
    對於A&返回型別,你若將之賦與其它變數,那麼它實際執行的是將返回的變數
    (或引用)代表的資料賦出..而你若將其它值賦予之,那麼被賦予的是變數或引
    用代表的資料. 而const A& 一般是防止之做為左值被賦值.

    這個地方還有很多的細節問題(譬如在連續賦值、返回的臨時物件的處理、
    過載的const和非cosnt運算子等等),讀者自己在實踐中需要多多總結.

二、難點
3. 修飾類成員函式的const.
   形如:void _Fun() const { };
   你需要知道的幾點規則：

   a.const物件只能訪問const成員函式,而非const物件可以訪問任意
     的成員函式,包括const成員函式.
   b.const物件的成員是不可修改的,然而const物件通過指標維護的物件卻
     是可以修改的.
   c.const成員函式不可以修改物件的資料,不管物件是否具有const性質.它在
     編譯時,以是否修改成員資料為依據,進行檢查.
   e.然而加上mutable修飾符的資料成員,對於任何情況下通過任何手段
     都可修改,自然此時的const成員函式是可以修改它的…

4.談談volatile和”完全const物件”
  一個有volatile修飾的類只允許訪問其介面的一個子集，這個子集由類的
  實現者來控制.使用者只有用const_cast才可以訪問這個型別的全部介面.而且,
  象const一樣，類的volatile屬性會傳遞給它的成員.想象const修飾的對
  象,它的成員變數是不可修改的,而它通過指標維護的物件或原生變數是可
  修改.那麼我們想:如果物件維護一個char* ,則它相當於char*
  const chrptr ;而不是const char* cosnt chrptr;對於類中的指標你需要
  這樣修飾以防止它或它維護的資源：cosnt x* xptr;而不是x*const xptr;
  因為cosnt 修飾的物件它預設 的行為是延續變數：x* cosnt xptr;

  更重要的,volatile修飾的資料,編譯器不可對其進行執行期寄存於暫存器的優化.
  這種特性,是為了多執行緒同步的需要.有興趣者看參看Andrei的GP系列文章.

5.談談const_cast轉換運算子
  這個關鍵字最基礎的用法是：去掉資料的const性質.
  值得注意的是：它只對指標、引用和其它的具有指向性質的型別.

 
mutable
mutable只能由於修飾類的非靜態資料成員，對於使用使用mutable修飾的成員變數，const成員函式可以改變其值，比如下面的程式碼：
class X{
public:
  void foo() const
  {
     if (!changed_){
       changed_ = true;
     }
     // do something
  }
private:
  mutable bool changed_;
};
如果缺少mutable，那麼就無法編譯通過啦。
mutable具有欺騙性，使用它，可以使const的成員函式悄悄的改變的類的成員函式，而無須使用const_cast來轉換this指標。
 
mutable和const
    宣告：這裡討論的const是用來修飾函式的const，而不是用來修飾變數的const。雖然是同一個關鍵字，但yayv還是覺得把他們當作2個關鍵字來理解更好一些。
    C++中const關鍵字用來表示一個常量，同時const也用來修飾函式。yayv在這個要明確的概念是：const所修飾的函式只能是類的成員函式，因為const所修飾的函式中，要由編譯器負責保護類的成員變數不被修改。而相對的，mutable則是用來修飾類的成員變數，讓該變數在const所修飾的成員函式中可以被修改。而且const修飾的函式只能是類的成員函式，mutable修飾的變數只能是類的成員變數。簡直就是一對冤家對頭~
這裡出現了3個問題：
第一：為什麼要保護類的成員變數不被修改
第二：為什麼用const保護了成員變數，還要再定義一個mutable關鍵字來突破const的封鎖線？
第三：到底有沒有必要使用const 和 mutable這兩個關鍵字？
    yayv對這三個問題的看法是：
    保護類的成員變數不在成員函式中被修改，是為了保證模型的邏輯正確，通過用const關鍵字來避免在函式中錯誤的修改了類物件的狀態。並且在所有使用該成員函式的地方都可以更準確的預測到使用該成員函式的帶來的影響。
    而mutable則是為了能突破const的封鎖線，讓類的一些次要的或者是輔助性的成員變數隨時可以被更改。
    沒有使用const和mutable關鍵字當然沒有錯，const和mutable關鍵字只是給了建模工具更多的設計約束和設計靈活性，而且程式設計師也可以把更多的邏輯檢查問題交給編譯器和建模工具去做，從而減輕程式設計師的負擔(yayv覺得這只不過是把負擔移交給了設計人員~, :（，並沒有降低任何工作量 )。
   如果開發過程有比較嚴格的迭代過程，使用這兩個關鍵字應該更能體現出他們的作用。

volatile
在Andrei Alexandrescu的文章《volatile - Multithreaded Programmer's Best Friend》[2]開頭有如下簡要描述：
The volatile keyword was devised to prevent compiler optimizations that might render code incorrect in the presence of certain asynchronous events. For example, if you declare a primitive variable as volatile, the compiler is not permitted to cache it in a register -- a common optimization that would be disastrous if that variable were shared among multiple threads. So the general rule is, if you have variables of primitive type that must be shared among multiple threads, declare those variables volatile. But you can actually do a lot more with this keyword: you can use it to catch code that is not thread safe, and you can do so at compile time. This article shows how it is done; the solution involves a simple smart pointer that also makes it easy to serialize critical sections of code.
volatile修飾的變數防止被優化，主要用在多執行緒程式中。避免編譯器優化。編譯器進行優化時，它有時會取一些值的時候，直接從暫存器裡進行存取，而不是從記憶體中獲取，這種優化在單執行緒的程式中沒有問題，但到了多執行緒程式中，由於多個執行緒是併發執行的，就有可能一個執行緒把某個公共的變數已經改變了，這時其餘執行緒中暫存器的值已經過時，但這個執行緒本身還不知道，以為沒有改變，仍從暫存器裡獲取，就導致程式執行會出現未定義的行為。