引用的本质是什么(c++,c#,java)？

转载自：http://www.cnblogs.com/rollenholt/articles/1907408.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

 

补充一点：对引用要注意一定不能 //char&   rc   =   pc;                 //cannot convert from 'char *' to 'char &',
    其中char g='g';   char   *pc   =   &g;  要char & rc=*pc 才正确。 cout<<rc<<endl; 输出 g

【分析：对引用的赋值可以转换成它的本质，即给常指针赋值，但同时要进行类型检查，即char类型的引用，他不仅被赋予一个地址，同时检查这个引用绑定的对象是不是char类型的。上面语句经过检查发现绑定的对象不是char类型的而是指针类型，所以报错。】

再补充一点：c#或java中的new运算符和c++中的new运算符意义有区别，java中new返回的是一个引用，而c++返回的是一个地址。

所以java中，

B refB = new B();   //在这里开始引用了

B=null;  //这句后，垃圾回收机制计时器会自减一下，若自减到0就会自动回收内存。

当然，实际上我们编程时都可以不写B=null这一句，只不过可能回收的慢一点，因为如果refB只要可能还要被用（比如类A中定义了类B的实例，只有A的实例被释放了，对应的类B的示例才被释放），垃圾回收机制就不自减，如果refB知道程序运行完了才确定不会被用到，这块内存岂不是一直留到最后。但本质上这并不是内存泄漏，只不过释放的晚一些而已。

而在C++中，

B objectB=new B();  //这里new返回的是一个对象的地址，并把地址绑定到objectB这个变量上，这里objectB变量和int a中的a没有什么区别，对编译器来说都是代表一个地址。

delect objectB;

objectB=null;

这时候释放objectB就要显示的使用delect了，否则那块内存一直被标记为“使用中”，永远得不到释放，在整个程序运行期间永远不会被回收。另外如果objectB是个链表的头指针的话，必须得用循环深入进去一个一个节点的释放，不能只释放头节点，否则其它节点就被泄漏了，因为那些节点对应的内存被标记为使用中，实际上确不用了，所以称为内存泄漏。

 

再补充一点：java或C#中的引用本质和C++中的引用本质完全不一样，前者本质就是一个指针（非常指针，只不过所有指针由系统维护，自动及时回收内存，如引用指向改变时，系统会首先回收原先的内存，所以不会像c++那样发生内存泄漏），而c++中的引用本质是个常指针，不能够随意更改指针的内容，只能被赋值一次（初始化时）。所以java中两个引用A=B，实际上是回收引用B指向的内存，而将A和B都指向A原来指向的内存。在c++中，两个引用A=B，可以看成两个变量的别名，实际上是将变量B‘的值复制给变量A’。

另外：在c++中对象名就相当于变量名，Class stu中的stu就相当于int a中的a，stu和a都是一块内存的标记罢了。但是在C#中stu就是引用，即一个指针，stu标记的是一个大约2字节的存放指针的内存，此时stu和a不一样。所以c++中的除非显示使用&符号定义，否则不是引用，就相当于一个变量名，而在C#中不用&符合定义引用，一个对象名就是一个引用，也即一个特殊一点的指针。