C++指针与引用

指针和引用形式上很好区别，可是他们彷佛有相同的功能,都可以直接引用对象，对其进行直接的操做。可是何时使用指针？何时使用引用呢？这二者很容易混淆,在此我详细介绍一下指针和引用，力争将最真实的一面展示给你们。若是我喷得不够好，但愿嘴下留情、手下留命，还请指点一二；若是感受还不错，请你们鼓掌。

一、指针和引用的定义

在深刻介绍以前咱们首先来看一下指针和引用的定义、指针和引用的区别，而后分别针对指针和引用展开讨论，深刻细节为什么有这些差别。

• 指针的权威定义：

In a declaration T D where D has the form * cv-qualifier-seqoptD1 And the type of the identifier in the declaration T D1 is "derived-declarator-type-list T", then the type of the identifier of D is "derived-declarator-type-list cv-qualifier-seq pointer to T". The cv-qualifiers apply to the pointer and not to the object pointer to. ——摘自《ANSI C++ Standard》 注：可能有些读者并不明白cv-qualifier-seq CV-qualifiers(CV限定符) CV-qualifiers有三种：const-qualifier(const限定符)、volatile-qualifier(volatile限定符)、以及const-volatile-qualifier(const-volatile限定符)。 const类对象的非静态、非mutable、以及非引用数据成员是const-qualified； volatile类对象的非静态、非引用数据成员是volatile-qualified； const-volatile类对象的非静态、非引用数据成员是const-volatile-qualified。 当CV-qualifiers用于限定数组类型时，其实是数组成员被该CV-qualifiers限定，而非该数组类型。 复合类型并不因其成员被CV-qualifier限定而被该CV-qualifier限定，也就是说，即便复合类型的成员有CV-qualifier限定，该复合类型也不是CV-qualified对象。

• 引用的权威定义：

In a declaration T D where D has the form & D1 And the type of the identifier in the declaration T D1 is "derived-declarator-type-list T", then the type of the identifier of D is "derived-declarator-type-list cv-qualifier-seq reference to T". Cv-qualified references are ill-formed except when the cv-qualifiers are introduced through the use of a typedef or a template type argument, in which case the cv-qualifiers are ignored. ——摘自《ANSI C++ Standard》

上面这些定义初看有些难懂，若是是这样的话，那说明你对C++还不够熟悉，你还有很长的路要走。下面用通俗易懂的话来概述一下：

• 指针-对于一个类型T，T*就是指向T的指针类型，也即一个T*类型的变量可以保存一个T对象的地址，而类型T是能够加一些限定词的，如const、volatile等等。见下图，所示指针的含义：

• 引用-引用是一个对象的别名，主要用于函数参数和返回值类型，符号X&表示X类型的引用。见下图，所示引用的含义：

二、指针和引用的区别

• 首先，引用不能够为空，但指针能够为空。前面也说过了引用是对象的别名，引用为空——对象都不存在，怎么可能有别名！故定义一个引用的时候，必须初始化。所以若是你有一个变量是用于指向另外一个对象，可是它可能为空，这时你应该使用指针；若是变量老是指向一个对象，i.e.，你的设计不容许变量为空，这时你应该使用引用。以下图中，若是定义一个引用变量，不初始化的话连编译都通不过（编译时错误）：

  而声明指针是能够不指向任何对象，也正是由于这个缘由，使用指针以前必须作判空操做，而引用就没必要。

• 其次，引用不能够改变指向，对一个对象"至死不渝"；可是指针能够改变指向，而指向其它对象。说明：虽然引用不能够改变指向，可是能够改变初始化对象的内容。例如就++操做而言，对引用的操做直接反应到所指向的对象，而不是改变指向；而对指针的操做，会使指针指向下一个对象，而不是改变所指对象的内容。见下面的代码：

  #include<iostream>

  usingnamespace 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>

usingnamespace 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++中引用传递与指针传递区别（进一步整理））

• 指针传递参数本质上是值传递的方式，它所传递的是一个地址值。值传递过程当中，被调函数的形式参数做为被调函数的局部变量处理，即在栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。值传递的特色是被调函数对形式参数的任何操做都是做为局部变量进行，不会影响主调函数的实参变量的值。
• 引用传递过程当中，被调函数的形式参数也做为局部变量在栈中开辟了内存空间，可是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操做都被处理成间接寻址，即经过栈中存放的地址访问主调函数中的实参变量。正由于如此，被调函数对形参作的任何操做都影响了主调函数中的实参变量。

引用传递和指针传递是不一样的，虽然它们都是在被调函数栈空间上的一个局部变量，可是任何对于引用参数的处理都会经过一个间接寻址的方式操做到主调函数中的相关变量。而对于指针传递的参数，若是改变被调函数中的指针地址，它将影响不到主调函数的相关变量。若是想经过指针参数传递来改变主调函数中的相关变量，那就得使用指向指针的指针，或者指针引用。

 

本文转自：http://www.cnblogs.com/skynet/archive/2010/09/22/1832911.html