前言

不少学习c语言的小白在写交换函数时都会碰到这样一个问题：明明在函数里已经进行了数值交换，但是输出的值并没有改变，还是之前的值。这是为什么呢？让我们一起来分析一下吧。

一、错误示范

我们初学者会想当然的用形参进行数值交换的操作，下面是演示代码：

void Swap1(int x, int y)
{
	int tmp = 0;
	tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 10;
	int b = 20;
	printf("交换前：     a=%d  b=%d\n", a, b);
	Swap1(a, b);
	printf("Swap1交换后：a=%d  b=%d\n", a, b);
	return 0;
}

输出结果：

我们发现，a和b的值并没有进行交换，为什么呢？函数里明明已经进行交换了呀？这样做的朋友就是对函数参数的传递理解还不够透彻，我们首先来理解一下函数的实参和形参。

1.实参

真实传给函数的参数，叫实参。实参可以是：常量、变量、表达式、函数等。无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

2.形参

形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。

    int a = 10;
	int b = 20;
	Swap1(a, b);

这里的a和b是确定的值，叫做实参，把他们传递给函数进行下一步操作。

void Swap1(int x, int y)

这里的x和y就是形参，用于接收 Swap1(a, b) 传递过来的参数，然后进行相应的处理，但是处理完以后变量就会自动销毁。这跟局部变量类似，只在局部的范围内起作用，用完就销毁了。而 Swap1函数返回值类型是void，没有返回任何值，所以最终的输出还是原来的a和b的值，没有发生任何改变。

也可这么理解，形参只是实参的一份拷贝，它们都有自己的独立空间，函数内部只是对拷贝的参数进行操作而不会影响到实参的数值。下图是调试状态下的监视窗口，我们可以看到两点重要的信息：

1. 分别查看了a，b和x，y的地址，它们并不相同，所以x，y的改变并不影响a，b。
2. 当程序走出函数体时，x，y都变成了灰色，表示已经被销毁了，这也印证了我们之前所说的结论。

二、正确示范

分析出了错误原因，接下来既然好办了。我们要找到a和b的地址，然后再改变其对应的值，这样才能达到真正的交换目的。以下是正确的代码：

void Swap2(int* px, int* py)
{
	int tmp = 0;
	tmp = *px;
	*px = *py;
	*py = tmp;
}
int main()
{
	int a = 10;
	int b = 20;
	printf("交换前：       a=%d  b=%d\n", a, b);
	Swap1(a, b);
	/*printf("Swap1交换后：a=%d  b=%d\n", a, b);*/
	Swap2(&a, &b);
	printf("Swap2交换后：  a=%d  b=%d\n", a, b);
	return 0;
}

输出结果：

这里涉及到了指针的用法，所谓指针就是地址的一个标记，举个通俗的例子。你去上课的时候，首先要找到教室在哪，你才能上课，而为了方便找到教室，每间教室都会进行相应的编号，如E405就表示E楼的4层第5间教室，有了这个编号你就可以找到教室，找到教室以后，你可以对教室里的布局进行改变，例如你可以改变教室里的桌子数量。同样道理，在程序里你可以通过地址找到a和b，然后可以改变其对应的值。

调试程序后，我们发现a，b的地址和px，py的地址一模一样，说明函数已经定位到了a和b的空间，接下来只需要对相应的值进行交换，程序就能正确输出了。

三、总结

我们来进行总结，通过一个小小的交换函数，我们用到了很多知识，首先是函数的调用，涉及到实参和形参的使用，如果不理解清楚，很容易会出现逻辑上的错误。其次我们还学会用指针进行传参，这样就能真正的改变参量的值。所以学习还真不能只看到表面现象，理解到其背后的意义也是很重要的。

首先在看这一篇博客之前应该要了解到在main函数里面调用一个main函数外的函数，参数传过去只是一个拷贝的值。

如果直接把两个int传入函数，用一个中间变量交换他们俩，那么这只是改变了这个变量在swap函数里面的值，回到main里面就复原了。

那么，如何真正交换两个int变量的值呢？

用指针，把两个int的地址传过去才可以。
如下

#include <stdio.h>
void swap1(int a,int b)
{
	int temp;
	temp = a;
	a=b;
	b=temp;
}
void swap2(int *a,int *b)
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}
int main()
{
	int a=4,b=5;
	swap1(a,b);
	printf("假交换 a:%d b:%d\n",a,b);
	swap2(&a,&b);
	printf("真交换 a:%d b:%d",a,b);
}
//假交换 a:4 b:5
//真交换 a:5 b:4

函数调用栈

我们在编程中写的函数，会被编译器编译为机器指令，写入可执行文件，程序执行的时候，会把这个可执行文件加载到内存，在虚拟地址空间中的代码段存放。

如果在一个函数中调用另一个函数，编译器就会对应生成一条call指令，当程序执行到这条call指令时，就会跳到对应的函数入口处开始执行，而每一个函数的最后，都有一条ret指令，负责在函数结束后跳回到调用处继续执行。

栈区

函数执行的时候需要有足够的内存空间来存放局部变量，参数，返回值等数据，这些数据存在上图中的栈中。

栈就是先入后出，先入栈的在底部。

在虚拟地址空间的栈区，上面的是高地址，下面是低地址，放了一些数据，栈底通常称为栈基，栈顶又叫栈指针。

具体的栈帧布局是：

• 调用者栈基地址（也就是谁调用了这个函数）
• 局部变量
• 调用函数的返回值
• 参数

通过栈指针加上偏移来定位到每个参数和返回值。

比如栈指针+8字节处，就是栈指针的上一格，通过这种方式来进行偏移。

还记得我们之前说当在A函数中调用B函数时，会在A函数中插入一条call指令，当执行到call指令的时候，会去B函数开始处运行。

那么call指令做的事情就是：

1. 首先把A函数中下一条指令的地址入栈（栈基地址，当B函数执行完之后，可以再通过这个地址回到A函数的调用处继续执行A函数。）
2. 跳转到被调用函数的入口处执行（也就是被调用函数的栈帧，而所有的函数栈帧布局都遵循统一的结构约定。）

栈具体的入栈策略

程序执行时，CPU通过特定的寄存器来存运行时的栈基和栈指针，也有指令指针寄存器用来存储下一条要执行的指令地址。

执行指令的过程有两种，第一种是逐步扩张：

• 如果要执行入栈3这条指令，CPU读取之后，会先把指令指针移向下一条指令，然后栈指针向下移动，入栈数字3。
• 然后再执行入栈4这条指令，CPU读取之后，再把指令指针移向下一条指令，然后栈指针向下移动，入栈数字4。
• 一直往复。

Go语言中的是第二种——一次性分配，它会直接将栈指针移动到所需最大栈空间的位置，然后通过右边这种相对寻址的方式，来把对应的值入栈。

Go语言选择使用一次性分配的策略是有原因的，拿下图来讲，下面三个goroutine，初始分配的栈空间只有那么大，如果要逐步扩张的话，如果g2执行到最后了，但是接下来要执行的函数又要用掉很多的空间，如果函数栈是逐步扩张的，执行时就可能会发生栈访问越界。

函数栈帧的大小可以在编译时期确定， 对于栈消耗大的函数，Go编译器会在函数头部插入检测代码，如果发现需要进行栈增长，则会另外分配一段足够大的空间，然后把原来的内容移过来，并释放原来的空间。

call和ret的细节

首先我们可以看到，下面是栈区和代码段。

当代码段执行到对应的指令时，就会给栈中添加对应的元素，最终再把栈全部出栈。

假如说，我们是在函数A中的a1处调用函数B（函数B开始位置为b1）。

首先，在最开始的时候，寄存器在栈中的情况是这样的：

ip寄存器中存的是下一条要运行的指令，那么当我们的代码段运行到a1的call指令时，会做两件事：

首先会入栈返回地址a2，然后栈指针sp向下一格，然后给ip寄存器b1的指令地址，接下来要去B函数的开始处运行。

call指令就结束了。

接下来就要运行四步函数都要做的事：

• 第一步是先把栈指针sp移动到足够大的位置——s7上。
• 第二步是存储一下之前栈基bp寄存器的值，这样可以在运行完之后，还能回到原来的栈基地址。
• 第三步是把s5存入栈基地址。
• 接下来就要做函数剩下的指令了——参数，代码等，并一一入栈。

在函数B运行到最后——ret指令之前，编译器还会插入两条指令：

• 恢复调用者栈基。最开始我们分配了多少空间，此时就释放多少空间，修改bp寄存器为之前入栈的s1，bp继续指向s1处。
• 然后就到ret指令了，它首先会弹出call指令压栈的返回地址a2，sp赋值为s3。然后跳转到这个返回地址a2，把ip寄存器赋值为a2。 接下来可以从a2这里继续执行了。

简单来说，call指令会分配栈帧，ret指令又会释放栈帧，恢复到call之前的样子。通过这些指令的配合，就能实现函数的层层嵌套了。

函数传参和返回值

首先看一个例子，下面这个例子是交换两个局部变量的值，可以看到，结果并没有改变：

上面那个函数在栈中的分配如下：

• 首先分配局部变量的空间，然后把局部变量存进去。
• 然后分配被调用函数的参数，从右至左分配。先入栈第二个参数，再入栈第一个参数。传参是值拷贝，所以把两个参数的值压入栈。
• 接下来是call指令存入的返回地址。也就是fmt.Println这一行代码所对应的指令
• 再接下来就是swap函数栈帧了

当swap函数执行到a,b=b,a时，就会修改参数对应的值，但是调用者的局部变量a和b在上面，交换的并不是它们，所以最终结果显示没有交换成功。

我们再修改一下：

还是和上一次的一样，只是我们把指针作为参数，函数参数还是值类型，所以会拷贝两个地址的值。

再swap函数中，会将对应地址的值进行交换，修改的是调用者的局部变量a和b，所以最终修改成功。

通常，返回值是通过寄存器传递的，但是Go语言支持多返回值，所以在栈上分配返回值更合适。

接下来我们看一个有返回值的例子：

1. 一次性分配main函数栈帧，sp直接到达对应的位置。

2. 把局部变量压入栈

3. 压入栈函数返回值（默认为0）——因为栈是先入后出的缘故，所以一个函数的执行步骤要从后往前的压入栈。

4. 把函数参数压入栈

5. 保存调用者函数main的栈基地址以方便最后回到main函数。

6. 接下来进入函数incr的函数栈帧。 首先初始化局部变量b，默认为0,

7. 然后执行a++指令，把局部变量a的值加1.

8. 运行到b=a的指令，把参数a赋给局部变量b。

9. 接下来就是返回值和defer函数的问题。 在Go语言中，是先给返回值赋值，然后再执行defer函数。

10. 把局部变量b的值，拷贝到返回值空间。
11. 执行注册的defer函数，在defer函数中，参数a再次自增1，局部变量b也加1。但是需要注意的是它让局部变量b自增1，不代表就把返回值自增1，因为在defer之前，已经给返回值赋值过了，可以看下图，b的值是2，但是返回值还是1.

12. 把返回值给局部变量b
13. 输出a，b——0,1

接下来我们看这个例子，用的是命名返回值：

1. main函数的栈情况还是如下图右边所示。

2. 接下来会运动到incr函数的a++指令，然后把参数a的值加1.
3. return a指令赋值a变量的值给返回值局部变量b，此时b=a=1.
4. 运行defer函数，a++，b++，a和b都是2.
5. 此时返回值的位置为2，所以会把main函数中的局部变量b赋值为2.
6. 打印0,2

当函数A中调用函数B和函数C时，栈的寻址策略

1. 首先分配A函数的局部变量空间。

2. 因为后面有两个函数要执行，又因为Go是一次性分配空间的，所以会分配最大的参数和返回值空间，函数B比函数C的空间要大，就以函数B所需要的空间标准来分配，如下图r2~p1这么大的空间。

3. 接下来把函数B的参数和返回值压入栈，进入函数B的栈帧。

4. 当函数B执行完毕之后，会释放这两片空间。把函数C的参数和返回值压入栈，但是此时空间还是那么大，r1和p1是存在这片空间的上面，还是下面，还是中间？

最终的答案就是，会把r1和p1分配到最下面，和函数C的栈指针挨着，这样虽然上面会空出来一块，但是被调用者通过栈指针相对寻址自己的参数和返回值时会比较方便。