深入浅出之函数的参数传递方式

1 按值传递

按值传递也称传值，其传递形式是形参为普通变量，实参为表达式或变量，实参向形参赋值。

按值传递的特点是参数传递后，实参和形参不再有任何联系。需要注意的是，此时实参是表达式，故形参不可能给实参赋值。函数被调用时，系统为形参分配相应的存储单元，用于接受实参传递的数据。函数调用期间，形参和实参各自拥独立的存储丹云。函数电泳结束，系统回收分配给形参的存储单元。

传值调用的优点是函数调用对其外界的变量无影响，最多只能用return返回一个值，函数独立性强。

#include <QCoreApplication>
#include<iostream>

using namespace std;
// 函数声明
void swap(int x, int y);

int main(int argc, char *argv[])
{
    QCoreApplication aa(argc, argv);
    // 局部变量声明
    int a = 100;
    int b = 200;

    cout << a << endl;
    cout << b << endl;

    // 调用函数来交换值
    swap(a, b);

    cout << a << endl;
    cout << b << endl;
    return aa.exec();
}

/*!
 * \brief swap
 * \param x
 * \param y
 */
void swap(int x, int y)
{
   int temp;

   temp = x; /* 保存 x 的值 */
   x = y;    /* 把 y 赋值给 x */
   y = temp; /* 把 x 赋值给 y */

   return;
}

输出结果：
100
200
100
200

虽然在函数内改变了 a 和 b 的值，但是实际上 a 和 b 的值没有发生变化。 

2 按引用传递

按引用传递又称传引用。引用即变量的别名，对别名的访问就是对别名所关联的访问，直接传入对象而无需传递对象的地址，反之亦然，&称为引用符。

int i；
int &ai = i;// 定义int型引用ai是变量i的别名
ai = 15；//此时i的值也为15

使用引用应注意以下几点：

1） 定义引用时，应同时对它初始化，使它与一个类型相同的已有变量关联。

2） 一个引用与某变量关联；

3）引用主要用做函数的形参和返回值 

#include <QCoreApplication>

int max(int &x,int &y)
{
    return x>y?x:y;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    int x = 10,y = 9;
    int res = max(x,y); // x,y为实参
    qDebug("%d",res);
    return a.exec();
}

x是实参a的医用，y是实参b的引用，他们占用同一个内存单元，知识名称不同。引用的主要特点如下：

1） 高效的传递参数，避免了传值方式中的拷贝构造。引用传递实际上是传地址；

2） return语句最多返回一个值，而使用引用的形式可以修改多个实参变量的值； 

3）使用引用形参可以避免拷贝大的类型的类类型对象或容器类型对象；

 3 按指针方式

指针传递本质上和值传递差不多，实际上是把实际的指针参数传递给函数中创建的形参指针。不同的地方在于，指针传递的情况时，可以通过再函数中通过形参指针的间址访问对实际变量做出更改，这是值传递无法做到的。

指针的行为和其他非引用类型一样。当执行指针的拷贝操作时，拷贝的是指针的值。拷贝之后，两个指针是不同的指针。可以通过指针修改所指对象的值，传入的是变量对象的地址的拷贝。

#include <QCoreApplication>

int max(int *x,int *y)
{
    return *x>*y?*x:*y;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    int x = 10,y = 9;
    int res = max(&x,&y); // x,y为实参
    qDebug("%d",res);
    return a.exec();
}

4 指针和引用的区别 

(1)指针：指针是一个变量，只不过这个变量存储的是一个地址，指向内存的一个存储单元；而引用跟原来的变量实质上是同一个东西，只不过是原变量的一个别名而已。如：

int a=1;int *p=&a;

int a=1;int &b=a;

上面定义了一个整形变量和一个指针变量p，该指针变量指向a的存储单元，即p的值是a存储单元的地址。

而下面2句定义了一个整形变量a和这个整形a的引用b，事实上a和b是同一个东西，在内存占有同一个存储单元。

(2)可以有const指针，但是没有const引用；

(3)指针可以有多级，但是引用只能是一级（int **p；合法 而 int &&a是不合法的）

(4)指针的值可以为空，但是引用的值不能为NULL，并且引用在定义的时候必须初始化；

(5)指针的值在初始化后可以改变，即指向其它的存储单元，而引用在进行初始化后就不会再改变了。

(6)"sizeof引用"得到的是所指向的变量(对象)的大小，而"sizeof指针"得到的是指针本身的大小；

(7)指针和引用的自增(++)运算意义不一样；

5 三种传递方式内存分析 

#include "stdafx.h"
#include <iostream>

using namespace std;

//值传递
void swap1(int p,int q)
{
    int temp;
    temp=p;
    p=q;
    q=temp;
}

//指针传递，函数体内只有指针值的变化
void swap2(int *p,int *q)
{
    int temp;
    temp=*p;
    *p=*q;
    *q=temp;
}

//指针传递，函数体内只有指针的变化
void swap3(int *p,int *q)
{
    int *temp;
    temp=p;
    p=q;
    q=temp;
}

//引用传递
void swap4(int &p,int &q)
{
    int temp;
    temp=p;
    p=q;
    q=temp;
}

int main()
{ 
    int a=1,b=2;
    swap1(a,b);
    //swap2(&a,&b);
    //swap3(&a,&b);
    //swap4(a,b);
    cout<<a<<"  "<<b<<endl;
    return 0;
}

5.1.值传递

swap1函数实现的值传递，值传递传递的是实际参数的一个副本，如果对这句话不理解，那一步步调试看下内存分配情况。

执行到48行时，a和b的情况如下

接着进入swap1函数体内，如下所示

可以看到的是，p和q的地址和a与b的地址不一样，只是把a和b的值拷贝过去了，在swap1中对p和q操作只是对临时分配的栈中内容进行操作，函数执行完后形参就消失了，对原来的a和b不产生任何影响。所以swap1不能完成交换a和b值的功能

5.2.指针传递

swap2和swap3都是指针传递，swap2函数体内交换了p和q指向地址的值，swap3函数体内交换了p和q指向的地址。

先说swap2，进入swap2函数体内，如下所示

可以看到，形参指针p和q指向的是a和b的地址，而不是像值传递那样将实参的值拷贝到另外分配的地址中，运行到函数尾时，如下图

可以看到、指针p和q指向的地址没变，但地址中的值变了，也即a和b地址中的变了，就是a和b的值成功交换，继续调试可以看到正确的结果，如下图

再来看swap3，swap3运行到函数尾时的情况如下

可以看到p和q交换了地址，但最后函数执行完后的结果又如下所示

a和b的值并未交换，这是为什么呢？

swap3中，形参p和q会保存在栈中，p指向a的地址，q指向b的地址，使用temp指针完成了p和q的地址交换，即p指向b的地址，q指向了a的地址，但a和b地址中的值并未发生变化，这与swap2不同，swap2中是p指向的地址中的值(就是a)与q指向的地址中的值(b)交换，所以swap2执行完后a和b的值是交换了的。

5.3.引用传递

引用传递时，对形参的操作等同于对实参的操作，即传递的不会是实参的副本，而就是实参，进入swap4函数体内如下所示

看到这个内存分配，很明了了吧。最后会交换a和b的值。

参考：

1. C/C++中函数参数传递详解