详解引用「&」与指针「*」

60 阅读 0 评论 40 点赞

我是靠谱客的博主健忘冥王星，最近开发中收集的这篇文章主要介绍详解引用「&」与指针「*」，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

引入

C 语言中函数有两种传参的方式：传值和传址。以传值方式，在函数调用过程中会生成一份临时变量用形参代替，最终把实参的值传递给新分配的临时变量即形参。它的优点是避免了函数调用的一些副作用，但是它无法改变实参的值。函数调用完成之后实参的值不会发生改变，如果要改变实参的值，只能通过指针传地址过去。

1 void swap (int left, int right)
 2 {
 3 int temp = left;
 4 left = right;
 5 right = temp;
 6 }
 7 void swap (int *_pleft , int * _pRight)
 8 {
 9 assert (NULL ! = _pleft && NULL ! = _pRight) ;
10 int iTemp = * _pleft;
11 *_pleft = * _pRight;
12 *_pRight = iTemp;
13 }

通过传地址的方式是可以解决问题，但是传指针也有诸多隐患，很容易出现各种 “安全事故”。就如同你想剪指甲，别人却给了你一把杀猪刀，这不是大材小用么。因此 C++ 中引入了一种新的类型 – 引用。引用只是一个别名，它既解决了传值的缺陷，又不具有传地址的隐患，所以应用广泛

1 void swap (int& left, int& right)
2  {
3  int temp = left;
4  left = right;
5  right = temp;
6  }

引用概念

引用（reference）不是新定义一个变量，而是给已存在的对象取了一个别名，引用类型，引用另外一种类型。编译器不会为引用对象新开辟内存空间，它和它引用的对象共用同一块内存空间。

1 int num = 110;
2 int &number = num;         //number指向num（是num的另外一个名字）

一般在初始化变量时，初始值会被拷贝到新建的对象中。在定义引用时程序把引用和他的初始值绑定在一起，而不是将初始值拷贝给引用。一旦初始化完成引用就将和他的初始对象一直绑定在一块（同生共死）。你无法将引用重新绑定到另外一个对象上。

引用即别名

引用并非对象，相反的，它只是为一个已经存在的对象所起的另外一个名字。就好像一个人的名字本来叫张三，然后大家又给他取了一个名字叫阿三，其实张三和阿三是同一个人。定义一个引用之后，对其进行的所有操作都是在与之绑定的对象上进行的：

1 number = 120;      //把120赋给number指向的对象，此处即是赋给了num
2 int tmp = number; //与tmp = num执行结果一样

为引用赋值，实际上是把值赋给了与引用绑定的对象。获取引用的值，实际上是获取了与引用绑定的对象的值。同理，以引用作为初始值，实际上是以引用绑定的对象作为初始值。

引用的定义

（1）允许在一条语句中定义多个引用，其中每个引用标识符都必须以 & 开头；

（2）因为无法将引用重新绑定到另外一个对象上，因此引用必须初始化。

（3）因为引用本身不是一一个对象，所以不能定义引用的引用。

（4）一个变量可以有多个引用，而一个引用只能给一个变量对象。

（5）引用的类型要和与之绑定的对象严格匹配（不严谨）。

（6）引用只能绑定在对象上而不能和字面值或某个表达式计算的过程绑定在一起。

1 int i1 = 10, i2 = 20 ;     //i1和i2都是int型
2 int &r1 = i1, &r2 = i2;    //r1和r2都是引用
3 int &r3 ;                  //报错：引用必须初始化
4 int &r4 = i1, &r5 = i2;    //r1, r4同为i1的引用，r2, r5同为i2的引用
5 int &r4 = i2, &r5 = i1;    //报错：r4不能同时分别为i1和i2的引用
6 int &r6 = 10;              //报错：引用类型的初始值必须是一个对象
7 double i3 = 3.14;
8 int &r7 = i3;              //报错：此处引用类型的初始值必须是int型对象

引用与指针

相同点：

底层的实现方式相同，都是按照指针的方式来实现的：

不同点：

（1）定义上的区别：可以说指针即地址，因为指针是一个存储地址的变量，它指向内存的一个存储单元；引用即别名，引用跟原来的变量实质上是同一个东西，只不过是原变量的一个别名而已。

1 int a=1;int *p=&a; 
2 //定义了一个整形变量和一个指针变量p，该指针变量指向a的存储单元，即p的值是a存储单元的地址。
3 int a=1;int &b=a;
4 //定义了一个整形变量a和这个整形a的引用b，事实上a和b是同一个东西，在内存占有同一个存储单元。

（2）指针的值可以为空，但是引用的值不能为 NULL，并且引用在定义的时候必须初始化；

（3）引用定义时必须初始化，且在进行初始化后就不会再改变了。指针可以不用，正常情况下需初始化为 NULL，且指针的值在初始化后可以改变，即指向其它的存储单元；

（4）sizeof 求取的值不一样，“sizeof 引用” 得到的是所指向的变量 (对象) 的大小，而 “sizeof 指针” 得到的是指针本身的大小；

（5）指针和引用的自增 (++) 与自减（–）运算意义不一样，引用自加改变变量的内容，指针自加改变了指针指向；

（6）可以有多级指针，但是没有多级引用，（int **p；合法而 int &&a 是不合法的）；

（7）指针和引用的地址不同，引用的地址即所引用对象的地址。指针的地址就是它自己的地址，是内存中的一块实实在在的另一块内存；

（8）引用比指针更安全。不会出现像野指针这样的现象。

指针和引用作为函数参数进行传递时的区别

1 #include<iostream>
 2 using namespace std;
 4 void swap(int *a,int *b)
 5 {
 6 　　int temp=*a;
 7 　　*a=*b;
 8 　　*b=temp;
 9 }
10 int main(void)
11 {
12 　　int a=10,b=20;
13 　　swap(&a,&b);
14 　　cout<<a<<" "<<b<<endl;
15 　　system("pause");
16 　　return 0;
17 }

输出结果为：20 10

用指针传递参数，可以实现对实参进行改变的目的，是因为传递过来的是实参的地址，因此使用 * a 实际上是取存储实参的内存单元里的数据，即是对实参进行改变，因此可以达到目的。

但是请看下面这个程序：

1 void test(int *p)
 2 {
 3 　　int a=1;
 4 　　p=&a;
 5 　　cout<<p<<" "<<*p<<endl;
 6 }
 7 int main(void)
 8 {
 9     int *p=NULL;
10     test(p);
11     if(p==NULL)
12     cout<<"指针p为NULL"<<endl;
13     system("pause");
14     return 0;
15 }

运行结果为：

0x22ff44 1

指针 p 为 NULL

为什么会这样呐？不是传递的地址么，怎么 p 会是 NULL？事实上，在 main 函数中声明了一个指针 p，并赋值为 NULL，当调用 test 函数时，事实上传递的也是地址，只不过传递的是值地址。什么意思呢？也就是说将指针作为参数进行传递时，实际上和传值形式的传参是相同的，只不过拷贝的的是地址。当把指针作为参数进行传递时，也是将实参的一个拷贝传递给形参，即上面程序 main 函数中的 p 和 test 函数中使用的 p 不是同一个变量，存储 2 个变量 p 的单元也不相同，即两个指针它们自己的地址不同（只是 2 个 p 指向同一个存储单元，里面保存的是同样的值），那么在 test 函数中对 p 进行修改，并不会影响到 main 函数中的 p 的值。

如果要想达到同时修改 main 函数中 p 的目的，就得使用二级指针或者引用了。

1 void test(int *&p)
 2 {
 3 　　int a=1;
 4 　　p=&a;
 5 　　cout<<p<<" "<<*p<<endl;
 6 }
 7 int main(void)
 8 {
 9     int *p=NULL;
10     test(p);
11     if(p!=NULL)
12     cout<<"指针p不为NULL"<<endl;
13     system("pause");
14     return 0;
15 }