基本认识

参数的传递本质上是一次赋值的过程。赋值就是对内存进行拷贝。所谓内存拷贝，是指将一块内存上的数据复制到另一块内存上。

对于像 char、bool、int、float 等基本类型的数据，它们占用的内存往往只有几个字节，对它们进行内存拷贝非常快速。而数组、结构体、对象是一系列数据的集合，数据的数量没有限制，可能很少，也可能成千上万，对它们进行频繁的内存拷贝可能会消耗很多时间，拖慢程序的执行效率。

C/C++ 禁止在函数调用时直接传递数组的内容，而是强制传递数组指针。而对于结构体和对象没有这种限制，调用函数时既可以传递指针，也可以直接传递内容；为了提高效率，建议传递指针，这样做在大部分情况下并没有什么不妥。

在 C++ 中，我们有了一种比指针更加便捷的传递聚合类型数据的方式，那就是引用（Reference）。

在 C/C++ 中，我们将 char、int、float 等由语言本身支持的类型称为基本类型，将数组、结构体、类（对象）等由基本类型组合而成的类型称为聚合类型（在讲解结构体时也曾使用复杂类型、构造类型这两种说法）。

引用（Reference）是 C++ 相对于C语言的又一个扩充。引用可以看做是数据的一个别名，通过这个别名和原来的名字都能够找到这份数据。引用类似于 Windows 中的快捷方式，一个可执行程序可以有多个快捷方式，通过这些快捷方式和可执行程序本身都能够运行程序；引用还类似于人的绰号（笔名），使用绰号（笔名）和本名都能表示一个人。

引用的定义方式类似于指针，只是用&取代了*，语法格式为：
type &name = data;
type 是被引用的数据的类型，name 是引用的名称，data 是被引用的数据。引用必须在定义的同时初始化，并且以后也要从一而终，不能再引用其它数据，这有点类似于常量（const 变量）。
下面是一个演示引用的实例：

1
2
3
4
5
6
7
8
9
#include <iostream>
using namespace std;
int main() {
    int a = 99;
    int &r = a;
    cout << a << ", " << r << endl;
    cout << &a << ", " << &r << endl;
    return 0;
}

运行结果：
99, 99
0x28ff44, 0x28ff44

本例中，变量 r 就是变量 a 的引用，它们用来指代同一份数据；也可以说变量 r 是变量 a 的另一个名字。从输出结果可以看出，a 和 r 的地址一样，都是0x28ff44；或者说地址为0x28ff44的内存有两个名字，a 和 r，想要访问该内存上的数据时，使用哪个名字都行。

注意，引用在定义时需要添加&，在使用时不能添加&，使用时添加&表示取地址。如上面代码所示，第 6 行中的&表示引用，第 8 行中的&表示取地址。除了这两种用法，&还可以表示位运算中的与运算。

由于引用 r 和原始变量 a 都是指向同一地址，所以通过引用也可以修改原始变量中所存储的数据，请看下面的例子：

1
2
3
4
5
6
7
8
9
#include <iostream>
using namespace std;
int main() {
    int a = 99;
    int &r = a;
    r = 47;
    cout << a << ", " << r << endl;
    return 0;
}

运行结果：
47, 47

最终程序输出两个 47，可见原始变量 a 的值已经被引用变量 r 所修改。

如果读者不希望通过引用来修改原始的数据，那么可以在定义时添加 const 限制，形式为：
const type &name = value;
也可以是：
type const &name = value;
这种引用方式为常引用。

C++引用作为函数参数

在定义或声明函数时，我们可以将函数的形参指定为引用的形式，这样在调用函数时就会将实参和形参绑定在一起，让它们都指代同一份数据。如此一来，如果在函数体中修改了形参的数据，那么实参的数据也会被修改，从而拥有“在函数内部影响函数外部数据”的效果。

一个能够展现按引用传参的优势的例子就是交换两个数的值，请看下面的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <iostream>
using namespace std;

void swap1(int a, int b);
void swap2(int *p1, int *p2);
void swap3(int &r1, int &r2);


int main() {
    int num1, num2;
    cout << "Input two integers: ";
    cin >> num1 >> num2;
    swap1(num1, num2);
    cout << num1 << " " << num2 << endl;

    cout << "Input two integers: ";
    cin >> num1 >> num2;
    swap2(&num1, &num2);
    cout << num1 << " " << num2 << endl;

    cout << "Input two integers: ";
    cin >> num1 >> num2;
    swap3(num1, num2);
    cout << num1 << " " << num2 << endl;

    return 0;
}

//直接传递参数内容
void swap1(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}

//传递指针
void swap2(int *p1, int *p2) {
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

//按引用传参
void swap3(int &r1, int &r2) {
    int temp = r1;
    r1 = r2;
    r2 = temp;
}

运行结果：
Input two integers: 12 34↙
12 34
Input two integers: 88 99↙
99 88
Input two integers: 100 200↙
200 100

本例演示了三种交换变量的值的方法：

  1. swap1() 直接传递参数的内容，不能达到交换两个数的值的目的。对于 swap1() 来说，a、b 是形参，是作用范围仅限于函数内部的局部变量，它们有自己独立的内存，和 num1、num2 指代的数据不一样。调用函数时分别将 num1、num2 的值传递给 a、b，此后 num1、num2 和 a、b 再无任何关系，在 swap1() 内部修改 a、b 的值不会影响函数外部的 num1、num2，更不会改变 num1、num2 的值。
  2. swap2() 传递的是指针，能够达到交换两个数的值的目的。调用函数时，分别将 num1、num2 的指针传递给 p1、p2，此后 p1、p2 指向 a、b 所代表的数据，在函数内部可以通过指针间接地修改 a、b 的值。
  3. swap3() 是按引用传递，能够达到交换两个数的值的目的。调用函数时，分别将 r1、r2 绑定到 num1、num2 所指代的数据，此后 r1 和 num1、r2 和 num2 就都代表同一份数据了，通过 r1 修改数据后会影响 num1，通过 r2 修改数据后也会影响 num2。

从以上代码的编写中可以发现，按引用传参在使用形式上比指针更加直观。在以后的 C++ 编程中，我鼓励读者大量使用引用，它一般可以代替指针（当然指针在 C++ 中也不可或缺），C++ 标准库也是这样做的。

C++引用作为函数返回值

引用除了可以作为函数形参，还可以作为函数返回值，请看下面的例子：
#include
using namespace std;
int &plus10(int &r) {
r += 10;
return r;
}
int main() {
int num1 = 10;
int num2 = plus10(num1);
cout << num1 << “ “ << num2 << endl;
return 0;
}
运行结果：
20 20

在将引用作为函数返回值时应该注意一个小问题，就是不能返回局部数据（例如局部变量、局部对象、局部数组等）的引用，因为当函数调用完成后局部数据就会被销毁，有可能在下次使用时数据就不存在了，C++ 编译器检测到该行为时也会给出警告。

更改上面的例子，让 plus10() 返回一个局部数据的引用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
using namespace std;
int &plus10(int &r) {
    int m = r + 10;
    return m;  //返回局部数据的引用
}
int main() {
    int num1 = 10;
    int num2 = plus10(num1);
    cout << num2 << endl;
    int &num3 = plus10(num1);
    int &num4 = plus10(num3);
    cout << num3 << " " << num4 << endl;
    return 0;
}

在 Visual Studio 下的运行结果：

1
2
20
-858993450 -858993450

在 GCC 下的运行结果：

1
2
20
30 30

在 C-Free 下的运行结果：

1
2
20
30 0

而我们期望的运行结果是：

1
2
20
20 30

plus10() 返回一个对局部变量 m 的引用，这是导致运行结果非常怪异的根源，因为函数是在栈上运行的，并且运行结束后会放弃对所有局部数据的管理权，后面的函数调用会覆盖前面函数的局部数据。本例中，第二次调用 plus10() 会覆盖第一次调用 plus10() 所产生的局部数据，第三次调用 plus10() 会覆盖第二次调用 plus10() 所产生的局部数据。

C++ 引用的本质

Q：引用在本质上是什么，它和指针到底有什么区别？

首先来回顾一下前面的例子：

1
2
3
4
5
6
7
8
9
#include <iostream>
using namespace std;
int main(){
    int a = 99;
    int &r = a;
    cout<<a<<", "<<r<<endl;
    cout<<&a<<", "<<&r<<endl;
    return 0;
}

运行结果：
99, 99
0x28ff44, 0x28ff44

我们知道，变量是要占用内存的，虽然我们称 r 为变量，但是通过&r获取到的却不是 r 的地址，而是 a 的地址，这会让我们觉得 r 这个变量不占用独立的内存，它和 a 指代的是同一份内存。

请读者再继续看下面的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include <iomanip>
using namespace std;
int num = 99;
class A{
public:
    A();
private:
    int n;
    int &r;
};
A::A(): n(0), r(num){}
int main (){
    A *a = new A();
    cout<<sizeof(A)<<endl;  //输出A类型的大小
    cout<<hex<<showbase<<*((int*)a + 1)<<endl;  //输出r本身的内容
    cout<<&num<<endl;  //输出num变量的地址
    return 0;
}

运行结果：
8
0x442000
0x442000

第 20 行代码中，hex表示以十六进制输出，showbase表示添加十六进制前缀0x。

从运行结果可以看出：

  • 成员变量 r 是占用内存的，如果不占用的话，sizeof(A)的结果应该为 4。
  • r 存储的内容是0x442000，也即变量 num 的地址。

这说明 r 的实现和指针非常类似。如果将 r 定义为int *类型的指针，并在构造函数中让它指向 num，那么 r 占用的内存也是 4 个字节，存储的内容也是 num 的地址。

其实引用只是对指针进行了简单的封装，它的底层依然是通过指针实现的，引用占用的内存和指针占用的内存长度一样，在 32 位环境下是 4 个字节，在 64 位环境下是 8 个字节，之所以不能获取引用的地址，是因为编译器进行了内部转换。以下面的语句为例：

1
2
3
4
int a = 99;
int &r = a;
r = 18;
cout<<&r<<endl;

编译时会被转换成如下的形式：

1
2
3
4
int a = 99;
int *r = &a;
*r = 18;
cout<<r<<endl;

使用&r取地址时，编译器会对代码进行隐式的转换，使得代码输出的是 r 的内容（a 的地址），而不是 r 的地址，这就是为什么获取不到引用变量的地址的原因。也就是说，不是变量 r 不占用内存，而是编译器不让获取它的地址。

当引用作为函数参数时，也会有类似的转换。以下面的代码为例：

1
2
3
4
5
6
7
8
9
//定义函数
void swap(int &r1, int &r2){
    int temp = r1;
    r1 = r2;
    r2 = temp;
}
//调用函数
int num1 = 10, num2 = 20;
swap(num1, num2);

编译时会被转换成如下的形式：

1
2
3
4
5
6
7
8
9
//定义函数
void swap(int *r1, int *r2){
    int temp = *r1;
    *r1 = *r2;
    *r2 = temp;
}
//调用函数
int num1 = 10, num2 = 20;
swap(&num1, &num2);

引用虽然是基于指针实现的，但它比指针更加易用，从上面的两个例子也可以看出来，通过指针获取数据时需要加*，书写麻烦，而引用不需要，它和普通变量的使用方式一样。

C++ 的发明人 Bjarne Stroustrup 也说过，他在 C++ 中引入引用的直接目的是为了让代码的书写更加漂亮，尤其是在运算符重载中，不借助引用有时候会使得运算符的使用很麻烦。

C++ 引用和指针的区别

  1. 引用必须在定义时初始化，并且以后也要从一而终，不能再指向其他数据；而指针没有这个限制，指针在定义时不必赋值，以后也能指向任意数据。
  2. 可以有 const 指针，但是没有 const 引用。也就是说，引用变量不能定义为下面的形式：
1
2
int a = 20;
int & const r = a;

因为 r 本来就不能改变指向，加上 const 是多此一举。

  1. 指针可以有多级，但是引用只能有一级，例如，int **p是合法的，而int &&r是不合法的。如果希望定义一个引用变量来指代另外一个引用变量，那么也只需要加一个&，如下所示：
1
2
3
int a = 10;
int &r = a;
int &rr = r;
  1. 指针和引用的自增（++）自减（–）运算意义不一样。对指针使用 ++ 表示指向下一份数据，对引用使用 ++ 表示它所指代的数据本身加 1；自减（–）也是类似的道理。请看下面的例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;
int main (){
    int a = 10;
    int &r = a;
    r++;
    cout<<r<<endl;
   
    int arr[2] = { 27, 84 };
    int *p = arr;
    p++;
    cout<<*p<<endl;
    return 0;
}

运行结果：
11
84

C++ 引用不能绑定到临时数据

临时数据：例如表达式的结果、函数的返回值等。

下面的代码演示了表达式所产生的临时结果：

1
2
3
4
int n = 100, m = 200;
int *p1 = &(m + n);    //m + n 的结果为 300
int *p2 = &(n + 100);  //n + 100 的结果为 200
bool *p4 = &(m < n);   //m < n 的结果为 false

这些表达式的结果都会被放到寄存器中，尝试用&获取它们的地址都是错误的。

什么样的临时数据会放到寄存器中

在C语言register中，我们知道只有较小的临时数据放在寄存器中。int、double、bool、char 等基本类型的数据往往不超过 8 个字节，用一两个寄存器就能存储，所以这些类型的临时数据通常会放到寄存器中；而对象、结构体变量是自定义类型的数据，大小不可预测，所以这些类型的临时数据通常会放到内存中。
下面的代码是正确的，它证明了结构体类型的临时数据会被放到内存中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
using namespace std;

typedef struct{
    int a;
    int b;
} S;

//这里用到了一点新知识，叫做运算符重载，我们会在《运算符重载》一章中详细讲解
S operator+(const S &A, const S &B){
    S C;
    C.a = A.a + B.a;
    C.b = A.b + B.b;
    return C;
}

S func(){
    S a;
    a.a = 100;
    a.b = 200;
    return a;
}

int main(){
    S s1 = {23, 45};
    S s2 = {90, 75};
    S *p1 = &(s1 + s2);
    S *p2 = &(func());
    cout<<p1<<", "<<p2<<endl;

    return 0;
}

运行结果：
0x28ff28, 0x28ff18

关于常量表达式

诸如 100、200+34、34.5*23、3+7/3 等不包含变量的表达式称为常量表达式（Constant expression）。

常量表达式由于不包含变量，没有不稳定因素，所以在编译阶段就能求值。编译器不会分配单独的内存来存储常量表达式的值，而是将常量表达式的值和代码合并到一起，放到虚拟地址空间中的代码区。从汇编的角度看，常量表达式的值就是一个立即数，会被“硬编码”到指令中，不能寻址。
总的来说，常量表达式的值虽然在内存中，但是没有办法寻址，所以也不能使用&来获取它的地址，更不能用指针指向它。下面的代码是错误的，它证明了不能用&来获取常量表达式的地址：

1
2
int *p1 = &(100);
int *p2 = &(23 + 45 * 2);

引用也不能指代临时数据

引用和指针在本质上是一样的，引用仅仅是对指针进行了简单的封装。引用和指针都不能绑定到无法寻址的临时数据，并且 C++ 对引用的要求更加严格，在某些编译器下甚至连放在内存中的临时数据都不能指代。

下面的代码中，我们将引用绑定到了临时数据：
typedef struct{
int a;
int b;
} S;
int func_int(){
int n = 100;
return n;
}
S func_s(){
S a;
a.a = 100;
a.b = 200;
return a;
}
//这里用到了一点新知识，叫做运算符重载，我们会在《运算符重载》一章中详细讲解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
S operator+(const S &A, const S &B){
    S C;
    C.a = A.a + B.a;
    C.b = A.b + B.b;
    return C;
}
int main(){
    //下面的代码在GCC和Visual C++下都是错误的
    int m = 100, n = 36;
    int &r1 = m + n;
    int &r2 = m + 28;
    int &r3 = 12 * 3;
    int &r4 = 50;
    int &r5 = func_int();
   
    //下面的代码在GCC下是错误的，在Visual C++下是正确的
    S s1 = {23, 45};
    S s2 = {90, 75};
    S &r6 = func_s();
    S &r7 = s1 + s2;
    return 0;
}

第 2833 行代码在 GCC 和 Visual C++ 下都不能编译通过，第 3839 行代码在 Visual C++ 下能够编译通过，但是在 GCC 下编译失败。这说明：

  • 在 GCC 下，引用不能指代任何临时数据，不管它保存到哪里；
  • 在 Visual C++ 下，引用只能指代位于内存中（非代码区）的临时数据，不能指代寄存器中的临时数据。

引用作为函数参数

当引用作为函数参数时，有时候很容易给它传递临时数据。下面的 isOdd() 函数用来判断一个数是否是奇数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
bool isOdd(int &n){
    if(n%2 == 0){
        return false;
    }else{
        return true;
    }
}
int main(){
    int a = 100;
    isOdd(a);  //正确
    isOdd(a + 9);  //错误
    isOdd(27);  //错误
    isOdd(23 + 55);  //错误
    return 0;
}

isOdd() 函数用来判断一个数是否为奇数，它的参数是引用类型，只能传递变量，不能传递常量或者表达式。但用来判断奇数的函数不能接受一个数字又让人感觉很奇怪，所以类似这样的函数应该坚持使用值传递，而不是引用传递。

下面是更改后的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
bool isOdd(int n){  //改为值传递
    if(n%2 == 0){
        return false;
    }else{
        return true;
    }
}
int main(){
    int a = 100;
    isOdd(a);  //正确
    isOdd(a + 9);  //正确
    isOdd(27);  //正确
    isOdd(23 + 55);  //正确
    return 0;
}

编译器会为const引用创建临时变量

引用不能绑定到临时数据，这在大多数情况下是正确的，但是当使用 const 关键字对引用加以限定后，引用就可以绑定到临时数据了。下面的代码演示了引用和 const 这一对神奇的组合：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
typedef struct{
    int a;
    int b;
} S;
int func_int(){
    int n = 100;
    return n;
}
S func_s(){
    S a;
    a.a = 100;
    a.b = 200;
    return a;
}
S operator+(const S &A, const S &B){
    S C;
    C.a = A.a + B.a;
    C.b = A.b + B.b;
    return C;
}
int main(){
    int m = 100, n = 36;
    const int &r1 = m + n;
    const int &r2 = m + 28;
    const int &r3 = 12 * 3;
    const int &r4 = 50;
    const int &r5 = func_int();
    S s1 = {23, 45};
    S s2 = {90, 75};
    const S &r6 = func_s();
    const S &r7 = s1 + s2;
    return 0;
}

这段代码在 GCC 和 Visual C++ 下都能够编译通过，这是因为将常引用绑定到临时数据时，编译器采取了一种妥协机制：编译器会为临时数据创建一个新的、无名的临时变量，并将临时数据放入该临时变量中，然后再将引用绑定到该临时变量。注意，临时变量也是变量，所有的变量都会被分配内存。

为什么编译器为常引用创建临时变量是合理的，而为普通引用创建临时变量就不合理呢？

  1. 我们知道，将引用绑定到一份数据后，就可以通过引用对这份数据进行操作了，包括读取和写入（修改）；尤其是写入操作，会改变数据的值。而临时数据往往无法寻址，是不能写入的，即使为临时数据创建了一个临时变量，那么修改的也仅仅是临时变量里面的数据，不会影响原来的数据，这样就使得引用所绑定到的数据和原来的数据不能同步更新，最终产生了两份不同的数据，失去了引用的意义。

以swap() 函数为例：

1
2
3
4
5
void swap(int &r1, int &r2){
    int temp = r1;
    r1 = r2;
    r2 = temp;
}

如果编译器会为 r1、r2 创建临时变量，那么函数调用swap(10, 20)就是正确的，但是 10 不会变成 20，20 也不会变成 10，所以这种调用是毫无意义的。

总起来说，不管是从“引用的语义”这个角度看，还是从“实际应用的效果”这个角度看，为普通引用创建临时变量都没有任何意义，所以编译器不会这么做。

  1. const 引用和普通引用不一样，我们只能通过 const 引用读取数据的值，而不能修改它的值，所以不用考虑同步更新的问题，也不会产生两份不同的数据，为 const 引用创建临时变量反而会使得引用更加灵活和通用。

以isOdd() 函数为例：

1
2
3
4
5
6
7
bool isOdd(const int &n){  //改为常引用
    if(n/2 == 0){
        return false;
    }else{
        return true;
    }
}

由于在函数体中不会修改 n 的值，所以可以用 const 限制 n，这样一来，下面的函数调用就都是正确的了：

1
2
3
4
5
int a = 100;
isOdd(a);  //正确
isOdd(a + 9);  //正确
isOdd(27);  //正确
isOdd(23 + 55);  //正确

对于第 2 行代码，编译器不会创建临时变量，会直接绑定到变量 a；对于第 3~5 行代码，编译器会创建临时变量来存储临时数据。也就是说，编译器只有在必要时才会创建临时变量。

C++ const引用与转换类型

类型严格一致：编译器禁止指针指向不同类型的数据。

引用（Reference）和指针（Pointer）在本质上是一样的，引用仅仅是对指针进行了简单的封装，「类型严格一致」这条规则同样也适用于引用。下面的例子演示了错误的引用使用方式：

1
2
3
4
5
6
int n = 100;
int &r1 = n;  //正确
float &r2 = n;  //错误
char c = '@';
char &r3 = c;  //正确
int &r4 = c;  //错误

「类型严格一致」是为了防止发生让人匪夷所思的操作，但是这条规则仅仅适用于普通引用，当对引用添加 const 限定后，情况就又发生了变化，编译器允许引用绑定到类型不一致的数据。请看下面的代码：

1
2
3
4
5
6
int n = 100;
int &r1 = n;  //正确
const float &r2 = n;  //正确
char c = '@';
char &r3 = c;  //正确
const int &r4 = c;  //正确

当引用的类型和数据的类型不一致时，如果它们的类型是相近的，并且遵守「数据类型的自动转换」规则，那么编译器就会创建一个临时变量，并将数据赋值给这个临时变量（这时候会发生自动类型转换），然后再将引用绑定到这个临时的变量，这与「将 const 引用绑定到临时数据时」采用的方案是一样的。

注意，临时变量的类型和引用的类型是一样的，在将数据赋值给临时变量时会发生自动类型转换。请看下面的代码：

1
2
3
float f = 12.45;
const int &r = f;
printf("%d", r);

该代码的输出结果为 12，说明临时变量和引用的类型都是 int（严格来说引用的类型是 int &），并没有变为 float。

当引用的类型和数据的类型不遵守「数据类型的自动转换」规则，那么编译器将报错，绑定失败，例如：

1
2
char *str = "http://c.biancheng.net";
const int &r = str;

char *和int两种类型没有关系，不能自动转换，这种引用就是错误的。

结合上节讲到的知识，总结起来说，给引用添加 const 限定后，不但可以将引用绑定到临时数据，还可以将引用绑定到类型相近的数据，这使得引用更加灵活和通用，它们背后的机制都是临时变量。

引用类型的函数形参请尽可能的使用 const

当引用作为函数参数时，如果在函数体内部不会修改引用所绑定的数据，那么请尽量为该引用添加 const 限制。

下面的例子演示了 const 引用的灵活性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <cstdio>
using namespace std;
double volume(const double &len, const double &width, const double &hei){
    return len*width*2 + len*hei*2 + width*hei*2;
}
int main(){
    int a = 12, b = 3, c = 20;
    double v1 = volume(a, b, c);
    double v2 = volume(10, 20, 30);
    double v3 = volume(89.4, 32.7, 19);
    double v4 = volume(a+12.5, b+23.4, 16.78);
    double v5 = volume(a+b, a+c, b+c);
    printf("%lf, %lf, %lf, %lf, %lf\n", v1, v2, v3, v4, v5);
    return 0;
}

运行结果：
672.000000, 2200.000000, 10486.560000, 3001.804000, 3122.000000

volume() 函数用来求一个长方体的体积，它可以接收不同类型的实参，也可以接收常量或者表达式。

概括起来说，将引用类型的形参添加 const 限制的理由有三个：

  • 使用 const 可以避免无意中修改数据的编程错误；
  • 使用 const 能让函数接收 const 和非 const 类型的实参，否则将只能接收非 const 类型的实参；
  • 使用 const 引用能够让函数正确生成并使用临时变量。