结论：

①C++中的引用本质上是 一种被限制的指针（类似于线性表和栈，栈是被限制的线性表，底层实现相同，只不过逻辑上的用法不同而已）。

②由于引用是被限制的指针，所以引用是占据内存的。

③在使用高级语言的层面上，是没有提供访问引用的方法的。并且引用创建时必需初始化，创建后还不能修改。

下面是找到的相关资料，来证明以上结论。

************************************************************************************

测试引用是占据内存的

C++中的“引用变量”它本身地址能不能取到呢？

用&总是取到的是它目标单元地址.

int a=7,b=8;
int &x=a; 如何得到x的地址 &x呢 ?

试了一下 &x，总是得到 a 的地址,而得不到x的地址
用C++BUILDER6测试。

我认为“引用”变量仍要占单元空间，存放的是一个地址，但编译器阻止你对它本身的任何访问，从一而终总是指向初始的目标单元，高手可以用插入汇编语句访问它的单元，在汇编里，引用的本质就是“间接寻址”，格式： [目标地址]
合法的办法不行，就只能用非法的办法了，利用引用的上一单元的地址，假设是连续分配的，
就是找到引用的地址了.全局变量是从上到下分配的，局部变量是从下往上倒着分配的（实验原理），下面用指针的办法改变了 引用对象。
#include "stdio.h"
int m=5,n=9;
int f=11; // f的下一地址就是g的
int &g=m;
// 全局变量
main()
{ // 局部变量
int a=5,b=9;
int u=11; // u的下一地址就是x的
int &x=a;

int **p=(int **)&u;
p[-1]=&b; // 下一地址就是x, 将它改到b的地址
printf("%d %d %d\n",a,b,x); // 呵呵，x 已改指到了b
//-------------------------------
int **q=(int **)&f;
q[1]=&n; // 下一地址就是g, 将它改到n的地址
printf("%d %d %d\n",m,n,g); // 呵呵，g 已改指到了n
}
我这是C++BUILDER6试的，正确! 证实了引用本质就是一个地址单元, 同样也分配空间。
但其它编译器不知能不能成。

资料出处：https://zhidao.baidu.com/question/570611106.html

*******************************************************************************************************************

对引用的详细分析

在大学的时候，教材里这么说的“引用是个别名...引用作为目标的别名而使用...引用不是值不占存储空间...引用只有声明，没有定义...” 那么，引用到底占不占内存空间，引用的本质是什么？

下面举个例子： int a = 10; int &b = a;

这里，显然，b是一个引用。 语句“int a = 10;”，在内存中申请了一个int型变量，32位机中占4个字节，那么变量名a放哪里了呢，有些人可能会有这个疑问。 其实a代表的是一个内存地址，you know，计算机访问内存中的数据，全部是通过地址进行访问（这个结论你可以从《汇编》的寻址方式中得出）。在编译器将你的代码生成目标文件时，它会用这个地址替代所有的a，因此目标文件中也就没有变量名a了，所以，变量名a不会占用内存也就理所当然了。 那么，引用 b会不会占内存空间呢？由于受大学课本的影响（引用b只是a的别名，b其实就是a本身），我很自然的会想到，b跟a一样，在编译后，所有的b也都用a的这个地址去替代，所以b也不会占用任何内存空间。 前段时间，这个问题在快速入门群和高级专业群中各位朋友讨论了一下，大家也众说纷纭。在网上也搜到很多帖子，说引用只是一个别名，它不会占用空间。 BUT，与各位高手的交流，查看众多网站，最后得出的结论是：   引用的本质是指针，而且是常量指针，占用4个字节的空间 也就是说，“int &b = a;”会开辟一块4个字节的空间，用于存放那个地址，当然,变量名b不会占用空间。 如果你听糊涂了，没关系，记住一条：引用b，本质就是一个常量指针（当然使用时不同）

下面是网络上比较权威的说法；另外，还有都史用于验证引用占内存的实例。如果大家有什么异议，本人希望与大家多多交流。

探索c++的底层机制

在看这篇文章之前，请你先要明白一点：那就是c++为我们所提供的各种存取控制仅仅是在编译阶段给我们的限制，也就是说是编译器确保了你在完成任务之前的正确行为，如果你的行为不正确，那么你休想构造出任何可执行程序来。但如果真正到了产生可执行代码阶段，无论是c，c++,还是pascal，大家都一样，你认为c和c++编译器产生的机器代码会有所不同吗，你认为c++产生的机器代码会有访问限制吗？那么你错了。什么const，private，统统没有（const变量或许会放入只读数据段），它不会再给你任何的限制，你可以利用一切内存修改工具或者是自己写一个程序对某一进程空间的某一变量进行修改，不管它在你的印象中是private，还是public，对于此时的你来说都一样，想怎样便怎样。另外，你也不要为c++所提供的什么晚期捆绑等机制大呼神奇，它也仅仅是在所产生的代码中多加了几条而已，它远没有你想象的那么智能，所有的工作都是编译器帮你完成，真正到了执行的时候，计算机会完全按照编译器产生的代码一丝不苟的执行。你明白我在说什么吗？对了，如果你从前接触过汇编，只要你反汇编一段c++代码，你就会说：原来是这么回事呀，c++只不过是把我们的问题进行了更高层次的抽象，但只要你解开面纱，回到问题的本源，一切都将变得不再神秘……

（以下的反汇编代码均来自visial c++ 7.0）  一．让我们从变量开始-----并非你想象的那么简单 变量是什么，变量就是一个在程序执行过程中可以改变的量。换一个角度，变量是一块内存区域的名字，它就代表这块内存区域，当我们对变量进行修改的时候，会引起内存区域中内容的改变。但是你若是学习过汇编或是计算机组成原理，那么你就会清楚对于一块内存区域来说，根本就不存在什么名字，它所仅有的标志就是他的地址，因此我们若想修改一块内存区域的内容，只有知道他的地址方能实现。看来所谓的变量一说只不过是编译器给我们进行的一种抽象，让我们不必去了解更多的细节，降低我们的思维跨度而已。例如下面这条语句： int a=10; 按照我们的思维习惯来讲，就是“存在一个变量a，它的值是10”，一切都显得那么的自然。我们不必去在乎什么所谓的地址以及其他的一些细节。然而在这条语句的底层实现中，a已经不能算是一个变量了，它仅仅是一个标记，代表一个地址的标记： mov dword ptr[a],0Ah; 怎么样，这条语句不像上面那条易于接受吧，因为它需要了解更多的细节，你几乎不能得到编译器的任何帮助，一切思维上的跨越必须由你自己完成。这条语句应该解释为“把10写入以a为地址的内存区域”。你说什么？a有些像指针？对，的确像，但还不是，只不过他们的过程似乎是类似的。这里所说的跨越实际上就是从一个现实问题到具体地址以及内存区域的跨越。 二．引用：你可以拥有引用，但编译器仅拥有指针（地址） 看过了第一条，你一定对编译器的工作有了一定的了解，实际上编译器就是程序员与底层之间的一个转换层，它把一个高级语言代码转换为低级语言代码，一个编译器完成的转换跨度越大，那么它也就会越复杂，因为程序员的工作都由他代为完成了。C++编译器必然比汇编编译器复杂就是这个道理。如果我问你引用和指针是一样的吗？你或许会说当然不一样了，指针容易产生不安全的因素，引用却不会，真的不会吗？我们来看下面这段代码： int *e=new int(10); int &f=*e; delete e; f=30; 你认为上面这段代码怎么样，我感觉就不很安全，它和指针有相同的隐患。因为它所引用的内存区域就不合法。 我个人认为，所谓的引用其实就是一种指针，只不过二者的接口并不相同，引用的接口有一定的限制。指针可以一对多，而引用却只能一对一，即&refer不能被改变，但却并不能说一对一就是安全的，只不过危险的系数降低罢了。引用比指针更容易控制。 Ok,下面来说说指针，曾经有过汇编经验的人一定会说，恩，指针的某些地方有些像汇编，尤其是那个“*”，怎么就那么像汇编中的“[]”啊。呵呵，的确，它也涵盖了一个寻址的过程。看来指针的确是个比较低级的东西。然而引用却并不那么直接，虽然程序员用起来方便安全了许多。但是你要清楚，只有你可以拥有引用，编译器可没有这个工具，计算机并不认识这个东西。因此，它的底层机制实际上是和指针一样的。不要相信只有一块内存拷贝，不要认为引用可以为你节省一个指针的空间，因为这一切不会发生，编译器还是会把引用解释为指针。不管你相不相信，请看下面这段代码： int& b=a; lea eax,[a]; mov dword ptr[b],eax;把a的地址赋给地址为b的一块内存

b=50; mov eax,dword ptr[b]; mov dword ptr[eax],32h;

int *d=&a; lea eax,[a]; mov dword ptr[d],eax

*d=60; mov eax,dword ptr[d] mov dword ptr[eax],3ch; 以上的代码均来自具体的编译器，怎么样，相信了吧，好，让我再来做一个或许不怎么恰当的比拟，你一定编过有关线性表和栈的程序吧，线性表是一个非常灵活的数据结构，在他上面有许多的操作，然而栈呢，它是一个限制性操作的线性表，它的底层操作实际上是由线性表操作实现的。就好比stack与vector的关系，因此指针和引用的关系就好比线性表和栈的关系，引用也就是受限的指针，它对外的接口和指针虽然并不一样，但底层是相同的。 下面再来看看引用的一个重要用途，作为函数的参数传递的时候是怎样的情形： void swapr(int &a, int &b)； void swapr(int* a, int *b)；

int a=10; int b=20;

swapr(a, b); lea eax,[a];  push eax; //把a的地址压入堆栈 lea ecx,[b]; push ecx; call swapr;

swapr(&a, &b); lea eax,[a]; push eax; lea ecx,[b]; push ecx; call swapr; 怎么样，用引用和指针传递参数无论是在效率上还是在空间上都是完全一样的，如果妄想不传入地址就修改实参的值，简直就是天方夜谭，这就说明引用的本质就是指针。毕竟它们的行为都太相似了，如果不是这样，你还有什么方法去实现引用吗？记住，引用只不过是编译器为你提供的一个有用且安全的工具，对于机器代码可无法表示它，它把指针一对多的缺点去除，禁止了你的不安全的操作。但回到问题的本源，他们没有任何区别。

都史的实例：

#include <iostream.h>

class A { double *m_pDb; };

class B { double &m_db; public: B(double db = 0) : m_db(db) {} };

int main() { cout << "size of class A:"<<sizeof(A) << endl; cout << "size of class B:"<<sizeof(B) << endl; return 0; }

结果：

size of class A:4

size of class B:4