首页 > 代码库 > C++指针和引用
C++指针和引用
本文主要整理自博文C++中的指针与引用及C++中引用传递与指针传递区别（进一步整理）。
1. 指针和引用的定义
1.1 指针
1.2 引用
2. 指针和引用的区别
共同点：
都是地址的概念。指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名。
2.1 引用不可以为空，但指针可以为空。
前面也说过了引用是对象的别名，引用为空——对象都不存在，怎么可能有别名！故定义一个引用的时候，必须初始化。因此如果你有一个变量是用于指向另一个对象，但是它可能为空，这时你应该使用指针；如果变量总是指向一个对象，也就是说，你的设计不允许变量为空，这时你应该使用引用。如下图中，如果定义一个引用变量，不初始化的话连编译都通不过（编译时错误，见下图）。而声明指针是可以不指向任何对象，也正是因为这个原因，使用指针之前必须做判空操作，而引用就不必。
2.2 引用不可以改变指向，对一个对象"至死不渝"；但是指针可以改变指向，而指向其它对象。
说明：虽然引用不可以改变指向，但是可以改变初始化对象的内容。例如就++操作而言，对引用的操作直接反应到所指向的对象，而不是改变指向；而对指针的操作，会使指针指向下一个对象，而不是改变所指对象的内容。见下面的代码：
1 #include<iostream> 2 3 using namespace std; 4 5 int main(int argc, char** argv) 6 7 { 8 int i = 10; 9 int& ref = i;10 ref++;11 cout << "i=" << i << endl;12 cout << "ref=" << ref << endl;13 int j = 20;14 ref = j;15 ref++;16 cout << "i=" << i << endl;17 cout << "ref=" << ref << endl;18 cout << "j=" << j << endl;19 20 return 0;21 }
对ref的++操作是直接反应到所指变量之上，对引用变量ref重新赋值"ref=j"，并不会改变ref的指向，它仍然指向的是i，而不是j。理所当然，这时对ref进行++操作不会影响到j。而这些换做是指针的话，情况大不相同，请自行实验。输出结果如下：
2.3 引用的大小是所指向的变量的大小，因为引用只是一个（对象、某块内存）别名而已；指针是指针本身的大小，4个字节。
从上面也可以看出：引用比指针使用起来形式上更漂亮，使用引用指向的内容时可以之间用引用变量名，而不像指针一样要使用*；定义引用的时候也不用像指针一样使用&取址。
2.4 引用比指针更安全。
由于不存在空引用，并且引用一旦被初始化为指向一个对象，它就不能被改变为另一个对象的引用，因此引用很安全。对于指针来说，它可以随时指向别的对象，并且可以不被初始化，或为NULL，所以不安全。const 指针虽然不能改变指向，但仍然存在空指针，并且有可能产生野指针（即多个指针指向一块内存，free掉一个指针之后，别的指针就成了野指针）。
言而总之——它们的这些差别都可以归结为"指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名，引用不改变指向。"
3. 特别之处const
const对指针和引用的限定是有差别的：
3.1 常量指针VS常量引用
常量指针：指向常量的指针，在指针定义语句的类型前加const，表示指向的对象是常量。
定义指向常量的指针只限制指针的间接访问操作，而不能规定指针指向的值本身的操作规定性。
常量指针定义"const int* pointer=&a"告诉编译器，*pointer是常量，不能将*pointer作为左值进行操作。
常量引用：指向常量的引用，在引用定义语句的类型前加const，表示指向的对象是常量。也跟指针一样不能利用引用对指向的变量进行重新赋值操作。
个人注：在这个程序中，如果是令“i=20”是可以编译运行通过的。
3.2 指针常量VS引用常量
在指针定义语句的指针名前加const，表示指针本身是常量。在定义指针常量时必须初始化！而这是引用天生具来的属性，不用再引用指针定义语句的引用名前加const。
指针常量定义"int* const pointer=&b"告诉编译器，pointer是常量，不能作为左值进行操作，但是允许修改间接访问值，即*pointer可以修改。
3.3 常量指针常量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 int i=5; int& ref=i;"是不正确的。
常量也是不能被引用的。如“int & ref=5”是不正确的。
4. 指针和引用的实现
我们利用下面一段简单的代码来深入分析指针和引用:
1 #include<iostream> 2 using namespace std; 3 4 int main(int argc, char** argv) 5 { 6 int i = 1; 7 int& ref = i; 8 int x = ref; 9 cout << "x is " << x << endl;10 11 ref = 2;12 int* p = &i;13 cout << "ref = " << ref << ", i = " << i << endl;14 15 return 0;16 }
上面的代码用g++ test.c编译之后，然后反汇编objdump -d a.out，得到main函数的一段汇编代码如下：
1 08048714 < main > : 2 8048714 : 55 push %ebp 3 8048715 : 89 e5 mov %esp, %ebp 4 8048717 : 83 e4 f0 and $0xfffffff0, %esp//为main函数的参数argc、argv保留位置 5 804871a : 56 push %esi 6 804871b : 53 push %ebx 7 804871c : 83 ec 28 sub $0x28, %esp 8 804871f : c7 44 24 1c 01 00 00 movl $0x1, 0x1c(%esp) //将0x1存到esp寄存器中，即int i=1 9 8048726 : 0010 8048727 : 8d 44 24 1c lea 0x1c(%esp), %eax// esp寄存器里的变量i的地址传给eax11 804872b : 89 44 24 18 mov %eax, 0x18(%esp)//将寄存器eax中的内容（i的地址）传给寄存器中的变量ref，即int& ref=i12 804872f : 8b 44 24 18 mov 0x18(%esp), %eax//将寄存器esp中的ref传给eax，即i的地址13 8048733 : 8b 00 mov(%eax), %eax//以寄存器eax中的值作为地址，取出值给eax 8048735: 89 44 24 14 mov %eax,0x14(%esp) //将寄存器eax中的值传给寄存器esp中的x，即x=ref14 8048739 : c7 44 24 04 00 89 04 movl $0x8048900, 0x4(%esp)15 8048740 : 0816 8048741 : c7 04 24 40 a0 04 08 movl $0x804a040, (%esp)17 8048748 : e8 cb fe ff ff call 8048618 < _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt >18 804874d : 8b 54 24 14 mov 0x14(%esp), %edx19 8048751 : 89 54 24 04 mov %edx, 0x4(%esp)20 8048755 : 89 04 24 mov %eax, (%esp)21 8048758 : e8 5b fe ff ff call 80485b8 < _ZNSolsEi@plt >22 804875d : c7 44 24 04 38 86 04 movl $0x8048638, 0x4(%esp)23 8048764 : 0824 8048765 : 89 04 24 mov %eax, (%esp)25 8048768 : e8 bb fe ff ff call 8048628 < _ZNSolsEPFRSoS_E@plt >//从8048739~8048768这些行就是执行"cout<<"x is "<<x<<endl;"26 804876d : 8b 44 24 18 mov 0x18(%esp), %eax//将寄存器esp中的ref传到eax中27 8048771 : c7 00 02 00 00 00 movl $0x2, (%eax) //将0x2存到eax寄存器中28 8048777 : 8d 44 24 1c lea 0x1c(%esp), %eax// esp寄存器里的变量i的地址传给eax29 804877b : 89 44 24 10 mov %eax, 0x10(%esp) //将寄存器eax中的内容（即i的地址）传到寄存器esp中的p30 804877f : 8b 5c 24 1c mov 0x1c(%esp), %ebx31 8048783 : 8b 44 24 18 mov 0x18(%esp), %eax32 8048787 : 8b 30 mov(%eax), %esi33 8048789 : c7 44 24 04 06 89 04 movl $0x8048906, 0x4(%esp)34 8048790 : 0835 8048791 : c7 04 24 40 a0 04 08 movl $0x804a040, (%esp)36 8048798 : e8 7b fe ff ff call 8048618 < _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt >37 804879d : 89 74 24 04 mov %esi, 0x4(%esp)38 80487a1 : 89 04 24 mov %eax, (%esp)39 80487a4 : e8 0f fe ff ff call 80485b8 < _ZNSolsEi@plt >40 80487a9 : c7 44 24 04 0d 89 04 movl $0x804890d, 0x4(%esp)41 80487b0 : 0842 80487b1 : 89 04 24 mov %eax, (%esp)43 80487b4 : e8 5f fe ff ff call 8048618 < _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt >44 80487b9 : 89 5c 24 04 mov %ebx, 0x4(%esp)45 80487bd : 89 04 24 mov %eax, (%esp)46 80487c0 : e8 f3 fd ff ff call 80485b8 < _ZNSolsEi@plt >47 80487c5 : c7 44 24 04 38 86 04 movl $0x8048638, 0x4(%esp)48 80487cc : 0849 80487cd : 89 04 24 mov %eax, (%esp)50 80487d0 : e8 53 fe ff ff call 8048628 < _ZNSolsEPFRSoS_E@plt >//这些行就是执行"cout<<"ref = "<<ref<<", i = "<<i<<endl;"51 80487d5 : b8 00 00 00 00 mov $0x0, %eax52 80487da : 83 c4 28 add $0x28, %esp53 80487dd : 5b pop %ebx54 80487de : 5e pop %esi55 80487df : 89 ec mov %ebp, %esp56 80487e1 : 5d pop %ebp57 80487e2 : c3 ret
从汇编代码可以看出实际上指针和引用在编译器中的实现是一样的：
引用int& ref=i：
1 8048727: 8d 44 24 1c lea 0x1c(%esp),%eax // esp寄存器里的变量i的地址传给eax2 804872b: 89 44 24 18 mov %eax,0x18(%esp) //将寄存器eax中的内容（i的地址）传给寄存器中的变量ref，即int& ref=i
指针int* p=&i：
1 8048777: 8d 44 24 1c lea 0x1c(%esp),%eax // esp寄存器里的变量i的地址传给eax2 804877b: 89 44 24 10 mov %eax,0x10(%esp) //将寄存器eax中的内容（即i的地址）传到寄存器esp中的p
5. 指针传递与引用传递
当指针和引用作为函数的函数是如何传值的呢？
- 指针传递参数本质上是值传递的方式，它所传递的是一个地址值。值传递过程中，被调函数的形式参数作为被调函数的局部变量处理，即在栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行，不会影响主调函数的实参变量的值。
- 引用传递过程中，被调函数的形式参数也作为局部变量在栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。
引用传递和指针传递是不同的，虽然它们都是在被调函数栈空间上的一个局部变量，但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数，如果改变被调函数中的指针地址，它将影响不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量，那就得使用指向指针的指针，或者指针引用（如int*& a）。
6. 引用作为参数传递
6.1 传递可变参数
传统的C语言中，函数在调用时参数是通过值来传递的，这就是说函数的参数不具备返回值的能力。所以在传统的C语言中，如果需要函数的参数具有返回值的能力，往往是通过指针来实现的。比如，实现两整数变量值交换的C程序如下：
1 void swap(int * a, int * b)2 {3 int temp = *a;4 *a = *b;5 *b = temp;6 }
使用引用机制后，以上程序的C++版本为：
1 void swap(int& a, int& b)2 {3 int temp = a;4 a = b;5 b = temp;6 }
引用形参是在主函数调用该函数的瞬间绑定实参的。因为每调用一次该函数都会建栈和清栈，所以该函数可以被多次调用，并不会受引用只能初始化一次的限制。
调用该函数的C++方法为：swap（x,y)。C++自动把x,y的地址作为参数传递给swap函数。
备注
如果我们定义的swap函数像这样：
1 void swap(int a,int b)2 {3 int temp = a;4 a=b;5 b=temp;6 }
那最后的结果是a、b的值并不会互相调换。因为主函数（如main()）在调用这个函数的时候会开始建栈，但当这个函数执行结束后会清栈，原来传进来的两个实参并没有互换。
6.2 给函数传递大型对象
当大型对象被传递给函数时，使用引用参数可使参数传递效率得到提高，因为引用并不产生对象的副本，也就是参数传递时，对象无须复制。在这里就不添加例子了。
6.3 引用返回值
如果一个函数返回了引用，那么该函数的调用也可以被赋值。这里有一函数，它拥有两个引用参数并返回一个双精度数的引用：
1 double& max(double& d1, double& d2)2 {3 return d1 > d2 ? d1 : d2;4 }
由于max()函数返回一个对双精度数的引用，那么我们就可以用max() 来对其中较大的双精度数加1：
1 max(x,y) += 1.0;
7. 关于引用的一个特别的例子
大家先看一下这个程序：
1 #include <iostream> 2 using namespace std; 3 4 float temp; 5 float fn(float r) 6 { 7 temp=(float)(r*r*3.14); 8 return temp; 9 }10 11 int main(int argc,char** argv)12 {13 float a=fn(5.0);14 float& b=fn(5.0);15 cout<<a<<endl;16 }
上例中的一行“float& b=fn(5.0);”是有问题的（有些编译器编译通过，但会有warning，有些则直接不通过。像VC就不通过）。主函数在调用fn函数时会建栈，而当fn执行完时又会清栈。像“float a=fn(5.0);”是没有问题的，因为a是主函数的一个局部变量，存储在主函数的栈中，函数fn计算后的结果会存储到变量a中；而“引用是某块内存的别名”，即使调用完fn清栈后，引用还是会指向同一块内存，但此时这块内存的内容可能已经不是函数fn计算后的结果了，而是乱数据，因此会出现错误。当然，上句的“float& b=fn(5.0)”改为“float& b=temp”是没问题的。
再看这个程序的修改版：
1 #include <iostream> 2 using namespace std; 3 4 float temp; 5 float& fn(float r) 6 { 7 temp=(float)(r*r*3.14); 8 return temp; 9 }10 11 int main(int argc,char** argv)12 {13 float a=fn(5.0);14 float& b=fn(5.0);15 cout<<a<<"\t"<<b<<"\n"<<endl;16 temp=50;17 cout<<a<<"\t"<<b<<endl;18 }
程序运行结果：
参考程序与运行结果可知：变量a只是被赋予函数fn返回的值而已，而变量b却绑定了全局变量temp。实际上，b就是temp（函数fn返回值）的引用。
再将程序修改如下（这时没有了全局变量temp，代之以函数局部变量a）：
1 #include <iostream> 2 using namespace std; 3 4 float& fn(float r) 5 { 6 float a; 7 a=(float)(r*r*3.14); 8 return a; 9 }10 11 int main(int argc,char** argv)12 {13 float a=fn(5.0);14 float& b=fn(5.0);15 cout<<a<<endl;16 cout<<b<<endl;17 }
程序运行结果：
很明显b输出的是错的，而且不同运行时b输出的值还不一样。具体原因与前面“个人注”第一段的解释一样。
更多问题稍后添加...
C++指针和引用