作者：RainMan
链接：https://www.zhihu.com/question/37608201/answer/545635054
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
 

引用是C++引入的重要机制（C语言没有引用），它使原来在C中必须用指针来实现的功能有了另一种实现的选择，在书写形式上更为简洁。那么引用的本质是什么，它与指针又有什么关系呢？

1.引用的底层实现方式

引用被称为变量的别名，它不能脱离被引用对象独立存在，这是在高级语言层面的概念和理解，并未解释引用的实现方式。常见错误说法是“引用”自身不是一个变量，甚至编译器可以不以引用分配空间。

实际上，引用本身是一个变量，只不过这个变量的定义和使用与普通变量有显著的不同。为了解引用变量底层实现机制，考查如下代码：

int i=5;
int &ri=i;
ri=8;

在Visual Studio 2017环境的debug模式调试代码，反汇编查看源码对应的汇编代码的步骤是：调试->窗口->反汇编，即可得到如下原码对应的汇编代码：

int i=5;
00A013DE  mov        dword ptr [i],5    	//将文字常量5送入变量i
int &ri=i;
00A013E5  lea        eax,[i]  	 	    	//将变量i的地址送入寄存器eax
00A013E8  mov        dword ptr [ri],eax  	//将寄存器的内容（也就是变量i的地址）送入变量ri
ri=8;
00A013EB  mov        eax,dword ptr [ri]  	//将变量ri的值送入寄存器eax
00A013EE  mov        dword ptr [eax],8   	//将数值8送入以eax的内容为地址的单元中
return 0;
00A013F4  xor        eax,eax

考查以上代码，在汇编代码中，ri的数据类型为dword，也就是说，ri要在内存中占据4个字节的位置。所以，ri的确是一个变量，它存放的是被引用对象的地址。由于通常情况下，地址是由指针变量存放的，那么，指针变量和引用变量有什么区别呢？使用指针常量实现上面的代码功能。考查如下代码：

int i=5;
int* const pi=&i;
*pi=8;

按照相同的方式，在VS2017中得都如下汇编代码：

int i=5;
011F13DE  mov         dword ptr [i],5  
int * const pi=&i;
011F13E5  lea         eax,[i]  
011F13E8  mov         dword ptr [pi],eax  
*pi=8;
011F13EB  mov         eax,dword ptr [pi]  
011F13EE  mov         dword ptr [eax],8  

观察以上代码可以看出：

（1）除了pi与ri变量名不同，所得汇编代码与第一段所对应的汇编代码完全一样。所以，引用变量在功能上等于一个指针常量，即一旦指向某一个单元就不能在指向别处。

（2）在底层，引用变量由指针按照指针常量的方式实现。

2.高级语言层面引用与指针常量的关系

1.引用和指针，在内存中都是占用4个字节（32bits系统中）的存储空间。指针和引用存放的都是被引用对象的地址，都必须在定义的同时进行初始化。

2.指针常量本身（以p为例）允许寻址，即&p返回指针常量（常变量）本身的地址，被引用对象用*p表示；引用变量本身（以r为例）不允许寻址，&r返回的是被引用对象的地址，而不是变量r的地址（r的地址由编译器掌握，程序员无法直接对它进行存取），被引用对象直接用r表示。

3.凡是使用了引用变量的代码，都可以转换成使用指针常量的对应形式的代码，只不过书写形式上要繁琐一些。反过来，由于对引用变量使用方式上的限制，使用指针常量能够实现的功能，却不一定能够用引用来实现。

例如，下面的代码是合法的：

int i=5,j=6;
int* const array[]={&i,&j};

而如下代码是非法的：

int i=5,j=6;
int& array[]={i,j};

也就是说，数组元素允许是指针常量，却不允许是引用。C++语言机制如此规定，原因是避免C++语法变得过于晦涩。假如定义一个“引用的数组”，那么array[0]=8;这条语句该如何理解？是将数组元素array[0]本身的值变成8呢，还是将array[0]所引用的对象的值变成8呢?对于程序员来说，这种解释上的二义性对正确编程是一种严重的威胁，毕竟程序员在编写程序的时候，不可能每次使用数组时都要回过头去检查数组的原始定义。

即得出两个不同：引用只能在定义时被初始化一次，之后不可变，但是指针可变；引用没有 const，指针有 const。

4.一些其他不同：

引用使用时无需解引用(*)，指针需要解引用；

“sizeof 引用”得到的是所指向的变量(对象)的大小，而“sizeof 指针”得到的是指针本身(所指向的变量或对象的地址)的大小；

引用不能为空，指针可以为空；

指针和引用的自增(++)运算意义不一样；引用自增被引用对象的值，指针自增内存地址。

 

https://blog.csdn.net/tianguiyuyu/article/details/102941951

c++中引用的本质

c++中引用就是一个常指针，其也占用内存空间。

1）引用在C++中的内部实现是一个常指针

Type& name 《-》Type* const name

2）C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。

3）从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。这是C++为了实用性而做出的细节隐藏

具体点：如下：

1）引用在实现上，只不过是把：间接赋值成立的三个条件的后两步和二为一

(简介赋值的三个条件： 1定义两个变量 （一个实参一个形参） 2建立关联 实参取地址传给形参  3 *p形参去间接的修改实参的值)

//当实参传给形参引用的时候，只不过是c++编译器帮我们程序员手工取了一个实参地址，传给了形参引用（常量指针）

如下图所示，c++编译器会把左边的代码翻译成右边的。

2）当我们使用引用语法的时，我们不去关心编译器引用是怎么做的

    当我们分析奇怪的语法现象的时，我们才去考虑c++编译器是怎么做的。

详细点就是看下面的代码：

    #include <iostream>

    using namespace std;

    //1 第一点 单独定义的引用时，必须初始化；说明很像一个常量

    void main1()

    {

    //

    const int c1 = 10;

    int a = 10;

    int& b = a; //b很想一个常量

    printf("&a:%d \n", &a);

    printf("&b:%d \n", &b); //===> a 和 b就是同一块内存空间的门牌号，a和b的地址是一样的，说明引用b就是a的别名

    cout << "hello..." << endl;

    system("pause");

    return;

    }

    //2 普通引用有自己的空间吗？ 有

    struct Teacher

    {

    char name[64]; //64

    int age; //4

    int& a; //4 0 //很像指针 所占的内存空间大小

    int& b; //4 0

    };

    //3 引用的本质

    void modifyA(int& a1)

    {

    a1 = 100;

    }

    void modifyA2(int* const a1)

    {

    *a1 = 200; //*实参的地址 ,去间接的修改实参的值

    }

    void main()

    {

    int a = 10;

    //1

    modifyA(a); //指向这个函数调用的时候,我们程序员不需要取a的地址

    printf("a:%d \n", a); //输出100

    //

    a = 10;

    modifyA2(&a); //如果是指针 需要我们程序员手工的取实参的地址

    printf("a:%d \n", a); //输出200

    printf("sizeof(Teacher):%d \n", sizeof(Teacher)); //输出76，说明普通引用有自己的内存空间

    system("pause");

    }

    void modifyA3(int* p)

    {

    *p = 200; //*p 3*p形参去间接修改实参的值

    }

    //间接赋值

    void main11()

    {

    int a = 10;

    int* p = NULL; //间接赋值成立的三个条件 1 定义两个变量

    p = &a;

    *p = 100;

    {

    *p = 200;

    }

    modifyA3(&a); //2 建立关联

    }


    // 123 写在一块

    // 12 3

    //1 23

 

目录

前言：

1、引用概念上是定义一个变量的别名，而指针是存储一个变量的地址。

2、引用在定义时必须要初始化，但是指针没有要求。

3、引用在初始化时引用一个实体后，就不能再引用其他实体，因为其本质是一个指针常量，无法改变指向。而指针可以在任何时候指向任何一个同类型实体。

4、没有NULL引用，但有NULL指针。

5、在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是空地址空间所占字节个数（32位平台下占用4个字节，64位占用8字节）。

6、引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。

7、有多级指针，但是没有多级引用。

8、访问实体方式不同，指针需要显示解引用，引用则由编译器自己处理。

9、引用比指针使用起来相对安全。

---

前言：

1、引用概念上是定义一个变量的别名，而指针是存储一个变量的地址。

 

2、引用在定义时必须要初始化，但是指针没有要求。

 

3、引用在初始化时引用一个实体后，就不能再引用其他实体，因为其本质是一个指针常量，无法改变指向。而指针可以在任何时候指向任何一个同类型实体。

 

4、没有NULL引用，但有NULL指针。

 

5、在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是空地址空间所占字节个数（32位平台下占用4个字节，64位占用8字节）。

 

6、引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。

 

7、有多级指针，但是没有多级引用。

 

8、访问实体方式不同，指针需要显示解引用，引用则由编译器自己处理。

 

9、引用比指针使用起来相对安全。

为什么C/C++语言使用指针？

答案：①一方面，每一种编程语言都使用指针。不止C/C++使用指针。

每一种编程语言都使用指针。C++将指针暴露给了用户(程序员)，而Java和C#等语言则将指针隐藏起来了。

“Everything uses pointers. C++ just exposes them rather than hiding them,”

It's easier to give someone an address to your home than to give a copy of your home to everyone.

②另一方面

使用指针的优点和必要性：

• 指针能够有效的表示数据结构；
• 能动态分配内存，实现内存的自由管理；
• 能较方便的使用字符串；
• 便捷高效地使用数组
• 指针直接与数据的储存地址有关，比如：值传递不如地址传递高效，因为值传递先从实参的地址中取出值，再赋值给形参代入函数计算；而指针则把形参的地址直接指向实参地址，使用时直接取出数据，效率提高，特别在频繁赋值等情况下（注意：形参的改变会影响实参的值！）

引用和指针有什么区别？

本质：引用是别名，指针是地址，具体的：

①从现象上看，指针在运行时可以改变其所指向的值，而引用一旦和某个对象绑定后就不再改变。这句话可以理解为：指针可以被重新赋值以指向另一个不同的对象。但是引用则总是指向在初始化时被指定的对象，以后不能改变，但是指定的对象其内容可以改变。
② 从内存分配上看，程序为指针变量分配内存区域，而不为引用分配内存区域，因为引用声明时必须初始化，从而指向一个已经存在的对象。引用不能指向空值。

注：标准没有规定引用要不要占用内存，也没有规定引用具体要怎么实现，具体随编译器 http://bbs.csdn.net/topics/320095541

③ 从编译上看，程序在编译时分别将指针和引用添加到 符号表上，符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值，而 引用在符号表上对应的地址值为 引用对象的地址值。符号表生成后就不会再改，因此指针可以改变指向的对象（指针变量中的值可以改），而引用对象不能改。这是使用指针不安全而使用引用安全的主要原因。从某种意义上来说 引用可以被认为是不能改变的指针。
④不存在指向空值的引用这个事实，意味着使用引用的代码效率比使用指针的要高。因为在使用引用之前不需要测试它的合法性。相反，指针则应该总是被测试，防止其为空。
⑤理论上，对于指针的级数没有限制，但是引用只能是一级。如下：
  int** p1;         // 合法。指向指针的指针
  int*& p2;         // 合法。指向指针的引用
  int&* p3;         // 非法。指向引用的指针是非法的
  int&& p4;         // 非法。指向引用的引用是非法的
  注意上述读法是 从左到右。 

 

来源： <http://www.tc5u.com/cpp/2400451.htm>

 

 

下面用通俗易懂的话来概述一下：

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

  

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

  

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

注意：正因为指针可以不指向任何对象，使用指针之前必须做判空操作，而引用就不必。

 

其次，引用不可以改变指向，对一个对象"至死不渝"；但是指针可以改变指向，而指向其它对象。说明：虽然引用不可以改变指向，但是可以改变初始化对象的内容。

例如就++操作而言，对引用的操作直接反应到所指向的对象，而不是改变指向；而对指针的操作，会使指针指向下一个对象，而不是改变所指对象的内容。

 

再次，引用的大小是所指向的变量的大小，因为引用只是一个别名而已；指针是指针（地址）本身的大小，32位系统下，一般为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;

1. double b=1;
2. constdouble& a=b;
3. b=2;//正确
4. a=3;//出错error: assignment of read-only reference `a'

 

 

 

总结：有一个规则可以很好的区分const是修饰指针，还是修饰指针指向的数据——画一条垂直穿过指针声明的星号（*），如果const出现在线的左边，指针指向的数据为常量；如果const出现在右边，指针本身为常量。而引用本身就是常量，即不可以改变指向。

 

指针传递和引用传递

为了更好的理解指针和引用，下面介绍一下指针传递和引用传递。当指针和引用作为函数的参数是如何传值的呢？

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

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

 

从概念上讲。指针从本质上讲就是存放变量地址的一个变量，在逻辑上是独立的，它可以被改变，包括其所指向的地址的改变和其指向的地址中所存放的数据的改变。

而引用是一个别名，它在逻辑上不是独立的，它的存在具有依附性，所以引用必须在一开始就被初始化，而且其引用的对象在其整个生命周期中是不能被改变的（自始至终只能依附于同一个变量）。

std::thread线程需要引用传递参数时，需要std::ref()支持

 

 最后，总结一下指针和引用的相同点和不同点：

★相同点：

●都是地址的概念；

指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名。

★不同点：

●指针是一个实体，而引用仅是个别名；

●引用只能在定义时被初始化一次，之后不可变；指针可变；引用“从一而终”，指针可以“见异思迁”；

●引用没有const，指针有const，const的指针不可变；

具体指没有int& const a这种形式，而const int& a是有的，前者指引用本身即别名不可以改变，这是当然的，所以不需要这种形式，后者指引用所指的值不可以改变）

●引用不能为空，指针可以为空；

●“sizeof 引用”得到的是所指向的变量(对象)的大小，而“sizeof 指针”得到的是指针本身的大小；

●指针和引用的自增(++)运算意义不一样；

●引用是类型安全的，而指针不是 (引用比指针多了类型检查）

 

参考文献：http://bbs.csdn.net/topics/80358667

http://www.guokr.com/post/443914/

http://blog.csdn.net/listening_music/article/details/6921608

http://www.tc5u.com/cpp/2400451.htm

转自：https://www.cnblogs.com/gxcdream/p/4805612.html

补充：

1。引用类型成员变量，不必初始化？必须在构造函数的初始化列表中进行初始化，所指定的变量的生存期一定要长于该类的生存期。

https://blog.csdn.net/lazyq7/article/details/48186291

https://blog.csdn.net/olivia77livy/article/details/79664232

https://blog.csdn.net/DirkNow/article/details/8664298