C/C++/C#引用传递，值传递，地址传递详细解析

一.首先要更正很多人的一个误区

很多人学习编程是从C语言开始学起的，也有些学习者从C++学起。初学者很容易混淆的一个是，C中没有引用传递的概念，而引用传递的概念是C++所持有的。因本身C++是C的超集，所以这一点很多人会下意识的进入这个误区。

二.什么是引用传递，它和值传递和指针传递有何异同？

1. 值传递。（代码由C语言实现）

#include <stdio.h>

//声明函数
void function(int getInt);

//主函数
int main()
{
	int initInt = 100;		//初始initInt的值
	printf("调用function前\tinitInt的值：\t");
	printf("%d\n", initInt);


	//调用函数function()，尝试通过function的形参getInt，改变initInt的值
	//观察initInt的值会不会因此受影响
	function(initInt);
	printf("调用function后\tinitInt的值：\t");
	printf("%d\n", initInt);
}

//函数定义
void function(int getInt)
{
	getInt = 60;
		printf("------------------------------------------------\n\
这里是在function()内部\n");
	printf("\t\tgetInt的值：\t");
	printf("%d\n",getInt);
	printf("End\n------------------------------------------------\n");
}

输出结果：

调用function前  initInt的值：   100
------------------------------------------------
这里是在function()内部
                getInt的值：    60
End
------------------------------------------------
调用function后  initInt的值：   100

分析：
从结果上看，当调用某个函数时，函数内更改形参的值时，并不会对传递的实参造成影响，即不会更改实参的值。
事实上，调用函数function()时，是在内存单元的栈中创建一个新空间getInt，并保存由initInt传过来的值100。因此，getInt和initInt相互独立，互不影响。当函数调用结束时，用于保存数值的getInt的空间就会被编译器回收。

2. 地址传递（代码由C++实现）

#include <iostream>

void function(int* ptrGet);

int main()
{
	//初始化，并把100所在的地址交给ptrInit
	int initInt = 100;
	int* ptrInit = &initInt;

	std::cout << "调用function前\tinitInt的值：\t" << initInt << std::endl;

	//调用函数function()，尝试通过function的形参ptrGet这个指针变量，改变initInt的值
	//观察initInt的值会不会因此受影响
	function(ptrInit);

	std::cout << "调用function后\tinitInt的值：\t" << initInt << std::endl;
}


void function(int* ptrGet)
{
	*ptrGet = 60;
	std::cout << "------------------------------------------------" << std::endl;
	std::cout << "这里是在function()内部\n" << "\t\tgetInt的值：\t";

	std::cout << *ptrGet << std::endl;

	std::cout << "End\n" << "------------------------------------------------" << std::endl;
	
}

输出结果：

调用function前  initInt的值：   100
------------------------------------------------
这里是在function()内部
                getInt的值：    60
End
------------------------------------------------
调用function后  initInt的值：   60

分析：
从结果上看，当调用某个函数时，当传入的参数为指针时，通过指针，能够改变实参的值。
所谓指针，其实就是地址，而地址在内存中表示方法，不过也就一串数字，因此这么分析下来，指针存储的是数字，不过这个数字有点特殊，是用来表示内存地址的。打个比方，指针存储的是别人家的门牌号，通过这个门牌号，才能正确访问这个房子里的主人，否则就敲错门了。
所以在function()参数传递的时候，就相当于，你有你朋友的门牌号，然后你把门牌号给了一个叫指针的房地产商，然后这个叫指针的房地产商既可以访问这个房子，又能改变房产证上房主的名字。（这个房地产商好像有点强啊~）

3. 引用传递（代码由C++实现）

#include <iostream>


void function(int& getInt);

int main()
{

	//初始化
	int initInt = 100;

	std::cout << "调用function前\tinitInt的值：\t" << initInt << std::endl;

	//调用函数function()，直接将initInt在内存中的地址传递给getInt
	//观察initInt的值会不会因此受影响
	function(initInt);

	std::cout << "调用function后\tinitInt的值：\t" << initInt << std::endl;
}



void function(int& getInt)
{
	getInt = 60;
	std::cout << "------------------------------------------------" << std::endl;
	std::cout << "这里是在function()内部\n" << "\t\tgetInt的值：\t";

	std::cout << getInt << std::endl;

	std::cout << "End\n" << "------------------------------------------------" << std::endl;
}

输出结果：

调用function前  initInt的值：   100
------------------------------------------------
这里是在function()内部
                getInt的值：    60
End
------------------------------------------------
调用function后  initInt的值：   60

分析：
很显然，这种方式的引用传递和指针传地址的效果是一样的。但是其实和指针完全不一样，引用传递的过程中，其实很容易理解，就是将initInt的名字换成getInt，然后在function()内更改getInt的值的时候，其实就是在更改initInt（在函数内时变成旧名）的值，initInt和getInt是相当于同一个人，只不过是换了个名字而已。
有人要问旧名initInt去哪了，其实只是被【initInt】被推入了栈暂时保存起来，等到函数调用结束后，再从栈中取回旧名。

下面附带部分反汇编：

function(initInt);
00755E48  lea         eax,[initInt]  			；字符串[initInt]被lea至eax寄存器
00755E4B  push        eax  						；eax寄存器上的字符串[initInt]被压入栈
00755E4C  call        function (075140Bh)  		；跳转到function所在的地址[0075140B]
00755E51  add         esp,4  

function:
0075140B  jmp         function (0751CD0h)  		；跳转到function内部

void function(int& getInt)
{
00751CD0  push        ebp  						；以下在做一些初始化处理
00751CD1  mov         ebp,esp  
00751CD3  sub         esp,0C0h  
00751CD9  push        ebx  
00751CDA  push        esi  
00751CDB  push        edi  
00751CDC  lea         edi,[ebp-0C0h]  
00751CE2  mov         ecx,30h  
00751CE7  mov         eax,0CCCCCCCCh  			
00751CEC  rep stos    dword ptr es:[edi]  
00751CEE  mov         ecx,offset _474518E8_C++_practice_1@cpp (075F025h)  
00751CF3  call        @__CheckForDebuggerJustMyCode@4 (075127Bh)  	
												;以上在做一些初始化处理
	getInt = 60;
00751CF8  mov         eax,dword ptr [getInt]  	；直接将[getInt]的地址传给eax寄存器
00751CFB  mov         dword ptr [eax],3Ch  		；将60赋值给getInt所在的地址中的值

三 . C#中的引用传递

首先C#有专门进行引用传递的关键字ref和out，这两个可以用来传递任何类型，只要在函数定义和函数调用时，在参数前面加ref或out就OK了。
ref和out关键字有什么区别呢？
（1）ref的原型为reference，专门用来表示实参传入某个函数后，实参上的数据在函数结束后将被更改。并且实参传入前需要显式初始化。
（2）out与ref关键字类似，只不过out没有必要在传入前显式初始化，即便初始化，也会被编译器无视。
共同点：
使用后都会改变原来实参上的数据。编译方式相同，因此两者无法互为重载。
不同点：
ref实参传入前必须初始化，out实参传入前没必要初始化。

	若对此还有不明白的，下面附带ref和out关键字的详细介绍（以下链接为转载）：
					https://www.cnblogs.com/sunliyuan/p/5999045.html

除了使用ref和out关键字进行引用传递外，C#还有一种隐藏的引用传递，而这很容易被人们所忽略，即当类所创建的实例（对象）作为参数时：

using System;

namespace C_Sharp
{
	class Program
	{
		static void Main(string[] args)
		{
			Class instance = new Class();

			Console.WriteLine("调用function前：");
			Console.Write("\t\tinstance.number:\t");
			Console.WriteLine(instance.number);
			Console.Write("\t\tinstance.className:\t");
			Console.WriteLine(instance.className);

			//调用函数function()，直接将initInt在内存中的地址传递给getInt
			//观察initInt的值会不会因此受影响
			function(instance);


			Console.WriteLine("调用function后：");
			Console.Write("\t\tinstance.number:\t");
			Console.WriteLine(instance.number);
			Console.Write("\t\tinstance.className:\t");
			Console.WriteLine(instance.className);


		}

		static void function(Class getClass)
		{
			getClass.number = 60;
			getClass.className = "The New Name!";

			Console.Write("------------------------------------------------\n" + 
				"这里是在function()内部\n"+ "\t\tgetClass.number的值：\t");
			Console.WriteLine(getClass.number);
			Console.Write("\t\tgetClass.className：\t");
			Console.WriteLine(getClass.className);
			Console.WriteLine("End\n------------------------------------------------");
		}

		static void function(string Name)
		{
			Name = "The New Name!";
			Console.WriteLine(Name);
		}

	}

	class Class
	{
		public int number = 100;
		public string className = "The Old Name!";
	}
}

输出结果：

调用function前：
                instance.number:        100
                instance.className:     The Old Name!
------------------------------------------------
这里是在function()内部
                getClass.number的值：   60
                getClass.className：    The New Name!
End
------------------------------------------------
调用function后：
                instance.number:        60
                instance.className:     The New Name!

分析：

由此可以看出，当传入函数的参数为类所创建的实例（对象）时，也是按照引用传递的方式进行传递的。
为什么实例（对象）作为参数传递时，要用引用传递呢？
请好好思考一下，假如在函数内部无法对传进来的实例（对象）进行修改，那将这个实例（对象）传进来有何意义？那还不如直接在函数内部重新在堆里申请某个类所占空间大小的实例（对象）呢。