值传递和地址传递

在c/c++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。

栈：就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。
堆：就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
自由存储区：就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。
全局存储区（静态存储区）：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后有系统释放。
常量存储区：这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改。

对于编译器，它会搜集我们的变量名，比如我们定义了一个全局的int a;那么编译器都为我们做了什么呢？
它会为程序预留4个字节的空间（假设在32位平台），并把我们的变量名“a”保存进符号表，并用这个符号表的索引对应实际的空间。
如果下面出现b = a;那么它就会根据符号表找到变量的真正的物理位置，取得它的值，赋给b，现在b也是符号表中的一员。
这是写编译器需要做的，我们需要建立符号表

在 C 语言中，函数的参数传递方式有两种：值传递与地址传递。下面分别介绍这两种传递形式。

值传递

这种方式使用变量、常量、数组元素作为函数参数，实际是将实参的值复制到形参相应的存储单元中，即形参和实参分别占用不同的存储单元，这种传递方式称为“参数的值传递”或者“函数的传值调用”。



值传递的特点是单向传递，即主调函数调用时给形参分配存储单元，把实参的值传递给形参，在调用结束后，形参的存储单元被释放，而形参值的任何变化都不会影响到实参的值，实参的存储单元仍保留并维持数值不变。



来看下面一个调用示例：

1. #include <stdio.h>
2. /* 变量x、y为Swap函数的形式参数 */
3. void Swap(int x, int y)
4. {
5. int tmp;
6. tmp = x;
7. x = y;
8. y = tmp;
9. printf("x = %d, y = %d ", x, y);
10. }
11. int main(void)
12. {
13. int a=10;
14. int b=20;
15. /*变量a、b为Swap函数的实际参数*/
16. Swap(a, b);
17. printf("a = %d, b = %d ", a, b);
18. return 0;
19. }

在上面这个示例代码中，实参将值传递给形参，形参值发生互换后的值不能回传给主调函数。因此，主调函数中的数值不变，代码的运行结果为：

x = 20, y = 10

a = 10, b = 20



对于上面这个示例，或许有人会有如下疑问：上面的示例中明确地把 a、b 分别代入了 x、y 中，并在函数 Swap() 里完成了两个变量值的交换，为什么 a、b 变量值还是没有交换。其结果仍然是“a=10，b=20”，而不是“a=20，b=10”呢？



其实，原因很简单。函数在调用时，隐含地把实参 a 的值赋值给了参数 x，而将实参 b 的值赋值给了参数 y，如下面的代码所示：

1. /*将a的值赋值给x（隐含动作）*/
2. int x = a;
3. /*将a的值赋值给y（隐含动作）*/
4. int y = b;

因此，之后在 Swap() 函数体内再也没有对 a、b 进行任何操作。而在 Swap() 函数体内交换的只是 x、y，并不是 a、b，当然，a、b 的值没有改变。整个 Swap() 函数调用是按照如下顺序执行的：

1. /*将a的值赋值给x（隐含动作）*/
2. int x = a;
3. /*将a的值赋值给y（隐含动作）*/
4. int y = b;
5. int tmp;
6. tmp = x;
7. x = y;
8. y = tmp;
9. printf("x = %d, y = %d ", x, y);

由此可见，函数只是把 a、b 的值通过赋值传递给 x、y，在函数 Swap() 中操作的只是 x、y 的值，并不是 a、b 的值，这也就是所谓的参数的值传递。

地址传递

这种方式使用数组名或者指针作为函数参数，传递的是该数组的首地址或指针的值，而形参接收到的是地址，即指向实参的存储单元，形参和实参占用相同的存储单元，这种传递方式称为“参数的地址传递”。



地址传递的特点是形参并不存在存储空间，编译系统不为形参数组分配内存。（应该不对，有待考察验证）数组名或指针就是一组连续空间的首地址。因此在数组名或指针作函数参数时所进行的传送只是地址传送，形参在取得该首地址之后，与实参共同拥有一段内存空间，形参的变化也就是实参的变化。



来看下面一个调用示例：

1. void Swap(int *px, int *py)
2. {
3. int tmp;
4. tmp = *px;
5. *px = *py;
6. *py = tmp;
7. printf("*px = %d, *py = %d ", *px, *py);
8. }
9. int main(void)
10. {
11. int a=10;
12. int b=20;
13. Swap(&a, &b);
14. printf("a = %d, b = %d ", a, b);
15. return 0;
16. }

在上面的示例代码中，函数 void Swap(int*px,int*py) 中的参数 px、py 都是指针类型，在 main 函数中使用语句“Swap(&a,&b)”进行调用，该调用语句将 a 的地址(&a)代入 px，b 的地址(&b)代入 py。很显然，这里的函数调用有两个隐含操作：将 &a 的值赋值给参数 px，将 &b 的值赋值给参数 py，如下面的代码所示：

1. px = &a;
2. py = &b;

注意，这里与值传递方式存在着很大的区别。在值传递方式中，传递的是变量 a、b 的内容（即在上面的值传递示例代码中，将 a、b 的内容传递给参数 x、y）；而这里的地址传递方式则是将变量 a、b 的地址值（&a、&b）传递给参数 px、py。因此，整个 Swap() 函数调用是按照如下顺序执行的：

1. /*将&a的值赋值给px（隐含动作）*/
2. px = &a; /* ← */
3. /*将&b的值赋值给py（隐含动作）*/
4. py = &b;
5. int tmp;
6. tmp = *px;
7. *px = *py;
8. *py = tmp;
9. printf("*px = %d, *py = %d ", *px, *py);

这样，有了前两行的隐含赋值操作，指针变量 px、py 的值已经分别是变量 a、b 的地址值（&a、&b）。接下来，对“*px”“*py”的操作当然也就是对 a、b 变量本身的操作了。所以 Swap() 函数中的交换操作就是对 a、b 值进行交换，这就是所谓的地址传递，运行结果为：

*px = 20, *py = 10

a = 20, b = 10