C++中引用和指針的區別

下面用通俗易懂的話來概述一下：

• 指針-對於一個類型T，T*就是指向T的指針類型，也即一個T*類型的變量可以保存一個T對象的地址，而類型T是能夠加一些限定詞的，如const、volatile等等。見下圖，所示指針的含義：
  

• 引用-引用是一個對象的別名，主要用於函數參數和返回值類型，符號X&表示X類型的引用。見下圖，所示引用的含義：
  

  
  

二、指針和引用的區別

• 首先，引用不能夠爲空，但指針能夠爲空。前面也說過了引用是對象的別名，引用爲空——對象都不存在，怎麼可能有別名！故定義一個引用的時候，必須初始化。所以若是你有一個變量是用於指向另外一個對象，可是它可能爲空，這時你應該使用指針；若是變量老是指向一個對象，i.e.，你的設計不容許變量爲空，這時你應該使用引用。以下圖中，若是定義一個引用變量，不初始化的話連編譯都通不過（編譯時錯誤）：
  

  而聲明指針是能夠不指向任何對象，也正是由於這個緣由，使用指針以前必須作判空操做，而引用就沒必要。

• 其次，引用不能夠改變指向，對一個對象"至死不渝"；可是指針能夠改變指向，而指向其它對象。說明：雖然引用不能夠改變指向，可是能夠改變初始化對象的內容。例如就++操做而言，對引用的操做直接反應到所指向的對象，而不是改變指向；而對指針的操做，會使指針指向下一個對象，而不是改變所指對象的內容。見下面的代碼：
  

  #include<iostream>

  using namespace std;

  
  

  int main(int argc,char** argv)

  {

      int i=10;

      int& ref=i;

      ref++;

      cout<<"i="<<i<<endl;

      cout<<"ref="<<ref<<endl;

      int j=20;

      ref=j;

      ref++;

      cout<<"i="<<i<<endl;

      cout<<"ref="<<ref<<endl;

      cout<<"j="<<j<<endl;

      return 0;

  }

  對ref的++操做是直接反應到所指變量之上，對引用變量ref從新賦值"ref=j"，並不會改變ref的指向，它仍然指向的是i，而不是j。理所固然，這時對ref進行++操做不會影響到j。而這些換作是指針的話，狀況大不相同，請自行實驗。輸出結果以下：

• 再次，引用的大小是所指向的變量的大小，由於引用只是一個別名而已；指針是指針自己的大小，4個字節。見下圖所示：
  

  從上面也能夠看出：引用比指針使用起來形式上更漂亮，使用引用指向的內容時能夠之間用引用變量名，而不像指針同樣要使用*；定義引用的時候也不用像指針同樣使用&取址。

• 最後，引用比指針更安全。因爲不存在空引用，而且引用一旦被初始化爲指向一個對象，它就不能被改變爲另外一個對象的引用，所以引用很安全。對於指針來講，它能夠隨時指向別的對象，而且能夠不被初始化，或爲NULL，因此不安全。const 指針雖然不能改變指向，但仍然存在空指針，而且有可能產生野指針（即多個指針指向一塊內存，free掉一個指針以後，別的指針就成了野指針）。
  

總而言之，言而總之——它們的這些差異均可以歸結爲"指針指向一塊內存，它的內容是所指內存的地址；而引用則是某塊內存的別名，引用不改變指向。"

三、特別之處const

在這裏我爲何要提到const關鍵字呢？由於const對指針和引用的限定是有差異的，下面聽我一一到來。

• 常量指針VS常量引用
  

常量指針：指向常量的指針，在指針定義語句的類型前加const，表示指向的對象是常量。

定義指向常量的指針只限制指針的間接訪問操做，而不能規定指針指向的值自己的操做規定性。

常量指針定義"const int* pointer=&a"告訴編譯器，*pointer是常量，不能將*pointer做爲左值進行操做。

常量引用：指向常量的引用，在引用定義語句的類型前加const，表示指向的對象是常量。也跟指針同樣不能利用引用對指向的變量進行從新賦值操做。

• 指針常量VS引用常量
  

在指針定義語句的指針名前加const，表示指針自己是常量。在定義指針常量時必須初始化！而這是引用天生具來的屬性，不用再引用指針定義語句的引用名前加const。

指針常量定義"int* const pointer=&b"告訴編譯器，pointer是常量，不能做爲左值進行操做，可是容許修改間接訪問值，即*pointer能夠修改。

• 常量指針常量VS常量引用常量
  

常量指針常量：指向常量的指針常量，能夠定義一個指向常量的指針常量，它必須在定義時初始化。常量指針常量定義"const int* const pointer=&c"告訴編譯器，pointer和*pointer都是常量，他們都不能做爲左值進行操做。

而就不存在所謂的"常量引用常量"，由於跟上面講的同樣引用變量就是引用常量。C++不區分變量的const引用和const變量的引用。程序決不能給引用自己從新賦值，使他指向另外一個變量，所以引用老是const的。若是對引用應用關鍵字const，起做用就是使其目標稱爲const變量。即沒有：Const double const& a=1；只有const double& a=1；

總結：有一個規則能夠很好的區分const是修飾指針，仍是修飾指針指向的數據——畫一條垂直穿過指針聲明的星號（*），若是const出如今線的左邊，指針指向的數據爲常量；若是const出如今右邊，指針自己爲常量。而引用自己與天俱來就是常量，即不能夠改變指向。

四、指針和引用的實現

咱們利用下面一段簡單的代碼來深刻分析指針和引用:

#include<iostream>

using namespace std;

int main(int argc, char** argv)

{

int i=1;

int& ref=i;

int x=ref;

cout<<"x is "<<x<<endl;

ref=2;

int* p=&i;

cout<<"ref = "<<ref<<", i = "<<i<<endl;

}

上面的代碼用g++ test.c編譯以後，而後反彙編objdump -d a.out，獲得main函數的一段彙編代碼以下：

08048714 <main>: 8048714: 55　　　　push %ebp 8048715: 89 e5　　　mov %esp,%ebp 8048717: 83 e4 f0        and $0xfffffff0,%esp//爲main函數的參數argc、argv保留位置 804871a: 56            push %esi 804871b: 53            push %ebx 804871c: 83 ec 28        sub $0x28,%esp 804871f: c7 44 24 1c 01 00 00 movl $0x1,0x1c(%esp) //將0x1存到esp寄存器中，即int i=1 8048726: 00 8048727: 8d 44 24 1c  lea 0x1c(%esp),%eax// esp寄存器裏的變量i的地址傳給eax 804872b: 89 44 24 18    mov %eax,0x18(%esp)//將寄存器eax中的內容（i的地址）傳給寄存器中的變量ref，即int& ref=i 804872f: 8b 44 24 18        mov 0x18(%esp),%eax//將寄存器esp中的ref傳給eax，即i的地址 8048733: 8b 00        mov (%eax),%eax//以寄存器eax中的值做爲地址，取出值給eax 8048735: 89 44 24 14        mov %eax,0x14(%esp) //將寄存器eax中的值傳給寄存器esp中的x，即x=ref 8048739: c7 44 24 04 00 89 04     movl $0x8048900,0x4(%esp) 8048740: 08 8048741: c7 04 24 40 a0 04 08    movl $0x804a040,(%esp) 8048748: e8 cb fe ff ff    call 8048618 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt> 804874d: 8b 54 24 14    mov 0x14(%esp),%edx 8048751: 89 54 24 04        mov %edx,0x4(%esp) 8048755: 89 04 24        mov %eax,(%esp) 8048758: e8 5b fe ff ff    call 80485b8 <_ZNSolsEi@plt> 804875d: c7 44 24 04 38 86 04    movl $0x8048638,0x4(%esp) 8048764: 08 8048765: 89 04 24        mov %eax,(%esp) 8048768: e8 bb fe ff ff    call 8048628 <_ZNSolsEPFRSoS_E@plt>//從8048739~8048768這些行就是執行"cout<<"x is "<<x<<endl;" 804876d: 8b 44 24 18    mov 0x18(%esp),%eax//將寄存器esp中的ref傳到eax中 8048771: c7 00 02 00 00 00    movl $0x2,(%eax) //將0x2存到eax寄存器中 8048777: 8d 44 24 1c        lea 0x1c(%esp),%eax// esp寄存器裏的變量i的地址傳給eax 804877b: 89 44 24 10    mov %eax,0x10(%esp) //將寄存器eax中的內容（即i的地址）傳到寄存器esp中的p 804877f: 8b 5c 24 1c        mov 0x1c(%esp),%ebx 8048783: 8b 44 24 18    mov 0x18(%esp),%eax 8048787: 8b 30        mov (%eax),%esi 8048789: c7 44 24 04 06 89 04    movl $0x8048906,0x4(%esp) 8048790: 08 8048791: c7 04 24 40 a0 04 08    movl $0x804a040,(%esp) 8048798: e8 7b fe ff ff    call 8048618 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt> 804879d: 89 74 24 04    mov %esi,0x4(%esp) 80487a1: 89 04 24        mov %eax,(%esp) 80487a4: e8 0f fe ff ff    call 80485b8 <_ZNSolsEi@plt> 80487a9: c7 44 24 04 0d 89 04    movl $0x804890d,0x4(%esp) 80487b0: 08 80487b1: 89 04 24        mov %eax,(%esp) 80487b4: e8 5f fe ff ff     call 8048618 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt> 80487b9: 89 5c 24 04        mov %ebx,0x4(%esp) 80487bd: 89 04 24        mov %eax,(%esp) 80487c0: e8 f3 fd ff ff    call 80485b8 <_ZNSolsEi@plt> 80487c5: c7 44 24 04 38 86 04    movl $0x8048638,0x4(%esp) 80487cc: 08 80487cd: 89 04 24        mov %eax,(%esp) 80487d0: e8 53 fe ff ff    call 8048628 <_ZNSolsEPFRSoS_E@plt>//這些行就是執行"cout<<"ref = "<<ref<<", i = "<<i<<endl;" 80487d5: b8 00 00 00 00    mov $0x0,%eax 80487da: 83 c4 28        add $0x28,%esp 80487dd: 5b            pop %ebx 80487de: 5e            pop %esi 80487df: 89 ec        mov %ebp,%esp 80487e1: 5d            pop %ebp 80487e2: c3            ret

從彙編代碼能夠看出實際上指針和引用在編譯器中的實現是同樣的：

• 引用int& ref=i;
  

8048727: 8d 44 24 1c        lea 0x1c(%esp),%eax// esp寄存器裏的變量i的地址傳給eax

804872b: 89 44 24 18    mov %eax,0x18(%esp)//將寄存器eax中的內容（i的地址）傳給寄存器中的變量ref，即int& ref=i

• 指針int* p=&i;
  

8048777: 8d 44 24 1c        lea 0x1c(%esp),%eax// esp寄存器裏的變量i的地址傳給eax

804877b: 89 44 24 10    mov %eax,0x10(%esp) //將寄存器eax中的內容（即i的地址）傳到寄存器esp中的p

雖然指針和引用最終在編譯中的實現是同樣的，可是引用的形式大大方便了使用也更安全。有人說："引用只是一個別名，不會佔內存空間？"經過這個事實咱們能夠揭穿這個謊話！實際上引用也是佔內存空間的。

五、指針傳遞和引用傳遞

爲了更好的理解指針和引用，咱們下面來介紹一下指針傳遞和引用傳遞。當指針和引用做爲函數的函數是如何傳值的呢？（下面這一段引用了C++中引用傳遞與指針傳遞區別（進一步整理））

• 指針傳遞參數本質上是值傳遞的方式，它所傳遞的是一個地址值。值傳遞過程當中，被調函數的形式參數做爲被調函數的局部變量處理，即在棧中開闢了內存空間以存放由主調函數放進來的實參的值，從而成爲了實參的一個副本。值傳遞的特色是被調函數對形式參數的任何操做都是做爲局部變量進行，不會影響主調函數的實參變量的值。

• 引用傳遞過程當中，被調函數的形式參數也做爲局部變量在棧中開闢了內存空間，可是這時存放的是由主調函數放進來的實參變量的地址。被調函數對形參的任何操做都被處理成間接尋址，即經過棧中存放的地址訪問主調函數中的實參變量。正由於如此，被調函數對形參作的任何操做都影響了主調函數中的實參變量。
  

引用傳遞和指針傳遞是不一樣的，雖然它們都是在被調函數棧空間上的一個局部變量，可是任何對於引用參數的處理都會經過一個間接尋址的方式操做到主調函數中的相關變量。而對於指針傳遞的參數，若是改變被調函數中的指針地址，它將影響不到主調函數的相關變量。若是想經過指針參數傳遞來改變主調函數中的相關變量，那就得使用指向指針的指針，或者指針引用。

從概念上講。指針從本質上講就是存放變量地址的一個變量，在邏輯上是獨立的，它能夠被改變，包括其所指向的地址的改變和其指向的地址中所存放的數據的改變。

而引用是一個別名，它在邏輯上不是獨立的，它的存在具備依附性，因此引用必須在一開始就被初始化，並且其引用的對象在其整個生命週期中是不能被改變的（自始至終只能依附於同一個變量）。

在C++中，指針和引用常常用於函數的參數傳遞，然而，指針傳遞參數和引用傳遞參數是有本質上的不一樣的：

指針傳遞參數本質上是值傳遞的方式，它所傳遞的是一個地址值。值傳遞過程當中，被調函數的形式參數做爲被調函數的局部變量處理，即在棧中開闢了內存空間以存放由主調函數放進來的實參的值，從而成爲了實參的一個副本。值傳遞的特色是被調函數對形式參數的任何操做都是做爲局部變量進行，不會影響主調函數的實參變量的值。（這裏是在說實參指針自己的地址值不會變）

而在引用傳遞過程當中，被調函數的形式參數雖然也做爲局部變量在棧中開闢了內存空間，可是這時存放的是由主調函數放進來的實參變量的地址。被調函數對形參的任何操做都被處理成間接尋址，即經過棧中存放的地址訪問主調函數中的實參變量。正由於如此，被調函數對形參作的任何操做都影響了主調函數中的實參變量。

引用傳遞和指針傳遞是不一樣的，雖然它們都是在被調函數棧空間上的一個局部變量，可是任何對於引用參數的處理都會經過一個間接尋址的方式操做到主調函數中的相關變量。而對於指針傳遞的參數，若是改變被調函數中的指針地址，它將影響不到主調函數的相關變量。若是想經過指針參數傳遞來改變主調函數中的相關變量，那就得使用指向指針的指針，或者指針引用。

爲了進一步加深你們對指針和引用的區別，下面我從編譯的角度來闡述它們之間的區別：

程序在編譯時分別將指針和引用添加到符號表上，符號表上記錄的是變量名及變量所對應地址。指針變量在符號表上對應的地址值爲指針變量的地址值，而引用在符號表上對應的地址值爲引用對象的地址值。符號表生成後就不會再改，所以指針能夠改變其指向的對象（指針變量中的值能夠改），而引用對象則不能修改。

最後，總結一下指針和引用的相同點和不一樣點：

★相同點：

●都是地址的概念；

指針指向一塊內存，它的內容是所指內存的地址；而引用則是某塊內存的別名。

★不一樣點：

●指針是一個實體，而引用僅是個別名；

●引用只能在定義時被初始化一次，以後不可變；指針可變；引用「從一而終」，指針能夠「見異思遷」；

●引用沒有const，指針有const，const的指針不可變；（具體指沒有int& const a這種形式，而const int& a是有     的，  前者指引用自己即別名不能夠改變，這是固然的，因此不須要這種形式，後者指引用所指的值不能夠改變）

●引用不能爲空，指針能夠爲空；

●「sizeof 引用」獲得的是所指向的變量(對象)的大小，而「sizeof 指針」獲得的是指針自己的大小；

●指針和引用的自增(++)運算意義不同；

●引用是類型安全的，而指針不是 (引用比指針多了類型檢查

1、引用的概念 引用引入了對象的一個同義詞。定義引用的表示方法與定義指針類似，只是用&代替了*。 例如： Point pt1(10,10); Point &pt2=pt1; 定義了pt2爲pt1的引用。經過這樣的定義，pt1和pt2表示同一對象。 須要特別強調的是引用並不產生對象的副本，僅僅是對象的同義詞。所以，當下面的語句執行後： pt1.offset（2，2）； pt1和pt2都具備（12，12）的值。 引用必須在定義時立刻被初始化，由於它必須是某個東西的同義詞。你不能先定義一個引用後才 初始化它。例以下面語句是非法的： Point &pt3； pt3=pt1； 那麼既然引用只是某個東西的同義詞，它有什麼用途呢？ 下面討論引用的兩個主要用途：做爲函數參數以及從函數中返回左值。 2、引用參數 一、傳遞可變參數 傳統的c中，函數在調用時參數是經過值來傳遞的，這就是說函數的參數不具有返回值的能力。 因此在傳統的c中，若是須要函數的參數具備返回值的能力，每每是經過指針來實現的。好比，實現 兩整數變量值交換的c程序以下： void swapint(int *a,int *b) { int temp; temp=*a; a=*b; *b=temp; } 使用引用機制後，以上程序的c++版本爲： void swapint(int &a,int &b) { int temp; temp=a; a=b; b=temp; } 調用該函數的c++方法爲：swapint（x,y); c++自動把x,y的地址做爲參數傳遞給swapint函數。 二、給函數傳遞大型對象 當大型對象被傳遞給函數時，使用引用參數可以使參數傳遞效率獲得提升，由於引用並不產生對象的 副本，也就是參數傳遞時，對象無須複製。下面的例子定義了一個有限整數集合的類： const maxCard=100; Class Set { int elems[maxCard]; // 集和中的元素，maxCard 表示集合中元素個數的最大值。 int card; // 集合中元素的個數。 public: Set () {card=0;} //構造函數 friend Set operator * (Set ,Set ) ; //重載運算符號*，用於計算集合的交集 用對象做爲傳值參數 // friend Set operator * (Set & ,Set & ) 重載運算符號*，用於計算集合的交集 用對象的引用做爲傳值參數 ... } 先考慮集合交集的實現 Set operator *( Set Set1,Set Set2) { Set res; for(int i=0;i<Set1.card;++i) for(int j=0;j>Set2.card;++j) if(Set1.elems==Set2.elems[j]) { res.elems[res.card++]=Set1.elems; break; } return res; } 因爲重載運算符不能對指針單獨操做，咱們必須把運算數聲明爲 Set 類型而不是 Set * 。 每次使用*作交集運算時，整個集合都被複制，這樣效率很低。咱們能夠用引用來避免這種狀況。 Set operator *( Set &Set1,Set &Set2) { Set res; for(int i=0;i<Set1.card;++i) for(int j=0;j>Set2.card;++j) if(Set1.elems==Set2.elems[j]) { res.elems[res.card++]=Set1.elems; break; } return res; }3、引用返回值 若是一個函數返回了引用，那麼該函數的調用也能夠被賦值。這裏有一函數，它擁有兩個引用參數並返回一個雙精度數的引用：double &max(double &d1,double &d2) { return d1>d2?d1:d2; }因爲max()函數返回一個對雙精度數的引用，那麼咱們就能夠用max() 來對其中較大的雙精度數加1：max(x,y)+=1.0;