C++中的指针与引用

写在前面

指针和引用形式上很好区别，但是他们似乎有相同的功能,都能够直接引用对象，对其进行直接的操作。但是什么时候使用指针？什么时候使用引用呢？这两者很容易混淆,在此我详细介绍一下指针和引用，力争将最真实的一面展现给大家。如果我写得不够好，希望嘴下留情、手下留命，还请指点一二；如果感觉还不错，请大家鼓掌。

1、指针和引用的定义

在深入介绍之前我们首先来看一下指针和引用的定义、指针和引用的区别，然后分别针对指针和引用展开讨论，深入细节为何有这些差异。

• 指针的权威定义：
  
• 引用的权威定义：
  
  上面这些定义初看有些难懂，如果是这样的话，那说明你对C++还不够熟悉，你还有很长的路要走。下面用通俗易懂的话来概述一下：
• 指针-对于一个类型T，T*就是指向T的指针类型，也即一个T*类型的变量能够保存一个T对象的地址，而类型T是可以加一些限定词的，如const、volatile等等。见下图，所示指针的含义：
• 
• 引用-引用是一个对象的别名，主要用于函数参数和返回值类型，符号X&表示X类型的引用。见下图，所示引用的含义：
  

2、指针和引用的区别

• 首先，引用不可以为空，但指针可以为空。 前面也说过了引用是对象的别名，引用为空——对象都不存在，怎么可能有别名！故定义一个引用的时候，必须初始化。因此如果你有一个变量是用于指向另一个对象，但是它可能为空，这时你应该使用指针；如果变量总是指向一个对象，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。而这些换做是指针的话，情况大不相同，请自行实验。输出结果如下：(对引用变量重新赋值ref=j,不会改变ref的指向，但是会把j的值赋值给ref)

如果是引用的话，代码如下:(这段是我自己加的，原文中并没有对应示例代码)

#include<iostream>

using namespace std;

int main(int argc,char** argv)

{
   int i = 10;

	int* ref = &i;
	i++;
	cout << "i=" << i << endl;
	cout << "ref value =" << *ref << endl;
	ref++;

	cout << "i=" << i << endl;
	cout << "ref=" << ref << endl;
	cout << "ref value =" << *ref << endl;

	int j = 20;
	cout << "redirect ref point to j" << endl;

	ref = &j;
	cout << "ref=" << ref << endl;
	cout << "ref value =" << *ref << endl;

	ref++;

	cout << "i=" << i << endl;
	cout << "ref=" << ref << endl;
	cout << "ref value =" << *ref << endl;
	cout << "j=" << j << endl;

	return 0;

}

执行结果如图:

• 再次，引用的大小是所指向的变量的大小，因为引用只是一个别名而已；指针是指针本身的大小，4个字节。见下图所示：
  
  从上面也可以看出：引用比指针使用起来形式上更漂亮，使用引用指向的内容时可以直接用引用变量名，而不像指针一样要使用*；定义引用的时候也不用像指针一样使用&取址。

最后，引用比指针更安全。由于不存在空引用，并且引用一旦被初始化为指向一个对象，它就不能被改变为另一个对象的引用，因此引用很安全。对于指针来说，它可以随时指向别的对象，并且可以不被初始化，或为NULL，所以不安全。const 指针虽然不能改变指向，但仍然存在空指针，并且有可能产生野指针（即多个指针指向一块内存，free掉一个指针之后，别的指针就成了野指针）。

总而言之，言而总之——它们的这些差别都可以归结为 "指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名，引用不改变指向。"

3、特别之处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出现在右边，指针本身为常量。而引用本身与天俱来就是常量，即不可以改变指向。

4、指针和引用的实现

我们利用下面一段简单的代码来深入分析指针和引用:

#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函数的一段汇编代码如下：



从汇编代码可以看出实际上指针和引用在编译器中的实现是一样的：

• 引用int& ref=i;
  
• 指针int* p=&i;
  
  虽然指针和引用最终在编译中的实现是一样的，但是引用的形式大大方便了使用也更安全。有人说："引用只是一个别名，不会占内存空间？"通过这个事实我们可以揭穿这个谎言！实际上引用也是占内存空间的。

5、指针传递和引用传递

为了更好的理解指针和引用，我们下面来介绍一下指针传递和引用传递。当指针和引用作为函数的函数是如何传值的呢？（下面这一段引用了C++中引用传递与指针传递区别（进一步整理））

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

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

参考文献:

[1]The C++ Programming Language(Special Edition),Bjarne Stroustrup
[2] ANSI C++ Standard
[3] 汇编语言

原文作者：吴秦
原文出处：http://www.cnblogs.com/skynet/

最后，使用&和*写了一个小demo

#include<iostream>
using namespace std;
int main(){
    int a=123;
    //&a表示a在内存中的地址，也就是123在内存中的地址
    cout<<"a: "<<a<<endl<<"a's address："<<&a<<endl;
    //此时p是一个指针，指向a所在的位置
    int *p=&a;
    cout<<"p: "<<p<<endl;
    //声明p之后，在p之前添加*表示p指向内存的值
    cout<<"p's value: "<<*p<<endl;
    //同时p也是 一个变量，在内存中也有一个地址储存它，但其地址不是a的地址
    cout<<"p's address: "<<&p<<endl;
    //试试*&组合使用是什么效果
    cout<<"*&p: "<<*&p<<endl;
    //&p是一个内存地址，*&p表示&p指向地址内存空间的值,在这里表示a的地址
    cout<<"**&p: "<<**&p<<endl;
    //刚才我们已经知道*&p是a的地址，那么**&p就表示a的值
    return 0;
}

输出结果：