上图中main方法中声明了a和b两个变量，然后通过swap2方法完成值交换。很简单的过程。（通过地址值进行引用然后完成交换）

图右边是代码的在栈帧的的一个交换过程：

大概说一下:

1. 首先初始化的main方法在栈帧 有两个内存空间 分别为0xaa00和0xbb00对应a和b的变量地址
2. 然后运行到调用swap2 产生栈帧空间，空间内 有x和y两个变量形参。
3. 然后swap2(&a,&b) 去地址值的方式把a和b的地址给了swap2方法 ,
4. swap2方法 的*x,*y=*y,*x是做了一个值交换，首先第一个*x是取内存空间(我们之前说过 ：等号左边的变量，代表变量所指向的内存空间)这里通俗来说就是*x是去main方法的栈帧下取到a的地址值(0xaa00)。
5. 第三个*y是根据地址把值取(等号右边的变量，代表变量内存空间存储的数据值)到然后赋值给*x（0xaa00）,取得的值为20 转化一下：0xaa00=20

一通百通

再来一个demo

主要看 new, new这个关键字是去（heap）堆内存申请一块内存空间，下面var p=new(*int)申请指针类型的内存 ，返回的是一块内存空间的地址值为0xc00001e090 ，想要给它赋值就必须进行取到0xc00001e090地址的空间*p，然后赋值*p=&i ，这个时候根据*p取得值是i的地址0xc0000be008值不是数据值，想要取得i的值需要再加个*就是**p,才能取到i的值。绕的一笔

func main() {
    var p =new(*int) //p 0xc00001e090
	var i int
	i=1000
	*p=&i
	fmt.Println(&i) //	0xc0000be008  i地址值
	fmt.Println(*p) //  0xc0000be008    i地址值
  fmt.Println(p)  //0xc00001e090     p变量的内存地址值
  fmt.Println(**p) // 1000          i的数据值1000
}

一、 引用

1.1 引用概念

        引用（reference）是为变量起了另一个名字，而不是定义一个新变量。编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。其使用形式如下：

        类型& 引用变量名(对象名) = 引用实体；

        eg:

int ival = 1024;
int &refVal = ival; // refVal 指向ival（是ival的另一个名字）
int &refVal2;    // 报错：引用必须被初始化

      定义引用时，程序把引用和它的初始化绑定在一起，而不是将初始值拷贝给引用。一旦初始化完成，引用将和它的初始值对象一直绑定在一起。因为无法令引用重新绑定到另外一个对象，所以引用必须初始化。注意：引用类型必须和引用实体是同种类型的。

1.2 引用的特性

           (1)  引用在定义式必须初始化；

         （2）一个变量可以有多个引用；

         （3）引用一旦引用一个实体，再不能引用其他实体；

1.3 引用的使用场景

     1 做参数

void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}

     2 做返回值

int& Count()
{
static int n = 0；
n++;
// ...
return n;
}

       注意：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

  例如下面代码就会出现问题。

int& Add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(3, 4);
	cout << "Add(1, 2) is :" << ret << endl;
	system("pause");
	return 0;
}


运行结果：
Add(1, 2) is :7
请按任意键继续. . .

           所以使用时注意作用域。

二、 传值和传引用的效率对比

    先用以下代码进行测试一下：

#include <time.h>
#include <iostream>
using namespace std;

struct A { int a[10000]; };
void TestFunc1(A a) {}  // 传值
void TestFunc2(A& a) {}  // 传引用
A a;
A Fun3() {
	return a;
}

A &Fun4() {
	return a;
}


void test1()
{
	A a;
	// 以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1(a);
	size_t end1 = clock();

	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2(a);
	size_t end2 = clock();
	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;

	// 以值作为函数返回值
	size_t begin3 = clock();
	for (size_t i = 0; i < 100000; ++i)
		Fun3();
	size_t end3 = clock();
	// 以引用作为函数返回值
	size_t begin4 = clock();
	for (size_t i = 0; i < 100000; ++i)
		Fun4();
	size_t end4 = clock();
	// 分别计算两个函数运行结束后的时间
	cout << "Fun3 time:" << end3 - begin3 << endl;
	cout << "Fun4 time:" << end4 - begin4 << endl;
}

int main()
{

	test1();
	system("pause");
	return 0;
}


运行结果:
TestFunc1(A)-time:129    <-- 参数传值
TestFunc2(A&)-time:2     <-- 参数传引用
Fun3 time:336            <-- 返回值为值
Fun4 time:2              <-- 返回值为引用
请按任意键继续. . .

      从运行结果可见传引用比传值的效率高很多。因为，以值做为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

三、 引用和指针的区别

     在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。但是在底层实现上，引用是按指针的方式实现的。怎么体现呢，看汇编代码。如下：

int main()
{
    int a = 10;
    int& ra = a;
    ra = 20;
    int* pa = &a;
    *pa = 20;
    return 0;
}

       将上面简单代码进行反汇编：

可见：

         在底层实现上：引用通过指针实现，定义一个引用类型变量相当于定义一个指针类型变量

         语法上： 引用是别名，不是指针，没有发生拷贝。

引用和指针的不同点:
     1. 引用在定义时必须初始化，指针没有要求
     2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
     3. 没有NULL引用，但有NULL指针
     4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
     5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
     6. 有多级指针，但是没有多级引用
     7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
     8. 引用比指针使用起来相对更安全

我们需要传数据而不改变数据存储，直接传值，如int a；

我们需要传数据，并且改变值大小，需要传地址，如  int * pa；

我们需要传数据，并改变数结构中指针的指向，需要传二级指针，如链表中的 node * * l；

...

这是c语言中传值的形式。参考我之前的一篇文章https://blog.csdn.net/weixin_41143631/article/details/82717506

以前是passl-by-value，而c++在c11中，引入了pass-by-reference，也就是传引用。c++需要一个标识符&。

给出下面代码

void my_swap(int* x, int* y)
{
	*x = *x^*y;
	*y = *x^*y;
	*x = *x^*y;
	cout << "函数中参数x的地址    " << &x << endl;
}
void my_swap(int&a, int&b)
{
	a = a^b;
	b = a^b;
	a = a^b;
	cout <<"函数中参数a的地址     "<< &a<< endl;

}
int main()
{
	int www = 1;
	int a = 0; int b = 100;
	int x = 0;   int y = 100;
	my_swap(&x, &y);
	my_swap(a, b);
	cout << a << "     主函数 a 的地址   "<<&a<<endl;
	cout << x << "  主函数x的地址  " <<&x<< endl;
}

前者swap是传值（生成拷贝，传地址），而后者直接是传引用，形参和实参的本质是一样，引用只是一个别名。

运行结果如下

可以明显看到，这2个重载函数中使用传指针，所指向的地址是不同的，而使用传引用，所指向的地址是相同的。

传引用：被调函数对形参的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。

传值：被调函数的形式参数作为被调函数的局部变量处理，即在栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。

int a=0;  //定义a是一个int类变量
int& ra=a;  //声明ra是a的“引用”，变量ra具有变量a的地址

//引用不能在引用的基础上再引用。

顺便说一下，gcc在编译时，O2级别优化，传引用，和传地址的汇编代码是一样的。

在微软的vc编译器（vs2013）运行时，直接优化，传引用，和传地址的汇编代码是一样的。

所以在我们写代码时，传引用，传指针都可以，不过我自己也趋向于写引用，在c++的模板中也大量使用引用，从制度上完善代码规范，能防微杜渐。

下面说一下，传引用，和我们常说的“传指针”之间的一些小区别。

A，传引用需要初始化，指针不需要（但指针推荐每次都初始化，即使无值，也初始化为NULL）。

B，使用sizeof对其求大小不一样，引用是对应数据的实际大小，而指针则依据机器固定为相应大小（32位为4字节）。

C，指针更加灵活，++，--可以来访问，而引用没有这些。有多级指针，没有多级引用。

D，引用相当于和被引用者“绑定”，而指针可以不断改变。

...

从安全的角度，引用能替代指针，这个在很多高级语言，不论是解释性语言还是编译语言中都得到了体现。

但维持c++的灵活，我们依然可以使用指针，不过推荐使用引用。