与非 const 引用(只能绑定到可修改左值)不同,const 引用可以绑定到可修改左值、不可修改左值和右值。因此,将引用参数设为 const 后,它就能绑定到任意类型的实参:
#include <iostream>
void printRef(const int& y) // y 是常量引用
{
std::cout << y << '\n';
}
int main()
{
int x { 5 };
printRef(x); // 正确:x 是可修改左值,y 绑定到 x
const int z { 5 };
printRef(z); // 正确:z 是不可修改左值,y 绑定到 z
printRef(5); // 正确:5 是右值字面量,y 绑定到临时 int 对象
return 0;
}
按 const 引用传递具有与按非 const 引用传递相同的主要优点(避免复制实参),同时还能保证函数不能修改被引用的值。
例如,下面的代码不允许这样做,因为 ref 是 const:
void addOne(const int& ref)
{
++ref; // 不允许:ref 是 const
}
大多数情况下,我们不希望函数修改实参的值。
最佳实践
除非有明确理由(例如函数需要修改实参的值),否则应优先按 const 引用传递,而不是按非 const 引用传递。
现在可以理解为什么允许 const 左值引用绑定右值:没有这个能力,就无法把字面量(或其他右值)传给使用引用传递的函数!
向 const 左值引用参数传递不同类型的实参
在课程 12.4 —— const 左值引用 中,我们提到,只要某个值能够转换为引用的类型,const 左值引用就可以绑定到不同类型的值。转换会创建一个临时对象,引用参数随后可以绑定到该临时对象。
允许这种行为的主要原因,是让我们能够以完全相同的方式,将值作为实参传给值参数或 const 引用参数:
#include <iostream>
void printVal(double d)
{
std::cout << d << '\n';
}
void printRef(const double& d)
{
std::cout << d << '\n';
}
int main()
{
printVal(5); // 5 转换为临时 double,再复制到参数 d
printRef(5); // 5 转换为临时 double,并绑定到参数 d
return 0;
}
按值传递时,我们本来就预期会发生复制,因此如果先发生类型转换(导致额外复制),通常不是问题(编译器很可能会优化掉两次复制中的一次)。
不过,我们经常在不希望复制时使用按引用传递。如果先发生类型转换,通常会产生一次(可能代价高昂的)复制,效果可能并不理想。
警告
按引用传递时,应确保实参类型与引用类型匹配,否则会产生意外且可能代价高昂的转换。
混合使用按值传递与按引用传递
包含多个参数的函数可以分别决定每个参数按值传递还是按引用传递。
例如:
#include <string>
void foo(int a, int& b, const std::string& c)
{
}
int main()
{
int x { 5 };
const std::string s { "Hello, world!" };
foo(5, x, s);
return 0;
}
上面的例子中,第一个实参按值传递,第二个按引用传递,第三个按 const 引用传递。
何时按值传递,何时按引用传递
对大多数 C++ 初学者来说,选择按值还是按引用并不直观。幸运的是,有一条简单的经验法则 这条经验法则在大多数情况下都适用。
- 基本类型和枚举类型复制成本低,因此通常按值传递。
- 类类型复制成本可能很高,因此通常按 const 引用传递。
最佳实践
经验法则是:基础类型按值传递,类类型按 const 引用传递。
如果不确定该怎么做,可以按 const 引用传递,这样更不容易遇到意外行为。
提示
下面列出一些其他情况:
以下类型通常按值传递(因为更高效):
- 枚举类型(无作用域和有作用域枚举)。
- 视图和 span(例如
std::string_view、std::span)。 - 模拟引用或(非拥有型)指针的类型(例如迭代器、
std::reference_wrapper)。 - 具有值语义且复制成本低的类类型(例如元素为基本类型的
std::pair、std::optional、std::expected)。
以下情况应按引用传递:
- 需要由函数修改的实参。
- 不可复制的类型(例如
std::ostream)。 - 复制会带来我们想避免的所有权影响的类型(例如
std::unique_ptr、std::shared_ptr)。 - 具有虚函数或可能被继承的类型(由于对象切片问题,详见课程 25.9 -- Object slicing).
按值传递与按引用传递的成本 进阶
并非所有类类型都需要按引用传递(例如通常按值传递的 std::string_view)。 你可能会疑惑为什么不把所有东西都按引用传递。本节(扩展阅读)将讨论按值传递和按引用传递的成本,并进一步完善两者的适用场景。
首先要考虑初始化函数参数的成本。按值传递意味着进行复制。复制对象的成本通常与两点成正比:
- 对象的大小。占用更多内存的对象复制时间更长。
- 额外的初始化成本。有些类在实例化时需要执行额外操作(例如打开文件或数据库,或分配一定量的动态内存来保存大小可变的对象)。每次复制对象都必须承担这些成本。
另一方面,将引用绑定到对象总是很快(速度大致相当于复制基础类型)。
其次要考虑使用函数参数的成本。建立函数调用时,编译器可能会将引用或按值传递的实参副本(如果体积较小)放入 CPU 寄存器,而不是访问速度较慢的 RAM。
每次使用值参数时,程序都可以直接访问参数副本的存储位置(CPU 寄存器或 RAM)。而使用引用参数时,通常需要额外一步。 程序必须先访问为引用分配的存储位置(CPU 寄存器或 RAM),确定引用的是哪个对象,然后才能访问被引用对象的存储位置(在 RAM 中)。
因此,使用值参数只需访问一次 CPU 寄存器或内存,而使用引用参数通常需要先访问一次引用,再访问一次被引用对象。
第三,编译器有时能更有效地优化按值传递的代码。尤其当存在 别名引用 (两个或更多指针或引用可以访问同一对象)的可能性时,优化器必须保持保守。按值传递会复制实参值,因此不会发生别名引用,优化器可以更积极地优化。
现在可以回答为什么不把所有参数都按引用传递:
- 对于复制成本低的对象,复制成本与绑定成本相近,但按值访问更快,编译器也更可能进行优化。
- 对于复制成本高的对象,复制成本会主导其他性能因素。
最后一个问题是,如何定义“复制成本低”?没有绝对答案,因为这取决于编译器、使用场景和体系结构。不过有一条实用经验:如果对象只占用不超过两个“字”(“字”大致等于一个内存地址的大小),且没有额外初始化成本,那么它的复制成本通常较低。
下面的程序定义了一个类似函数的宏,用于判断某个类型(或对象)的复制成本是否较低:
#include <iostream>
// 函数式宏:当类型(或对象)的大小小于等于
// 两个内存地址的大小时求值为 true
#define isSmall(T) (sizeof(T) <= 2 * sizeof(void*))
struct S
{
double a;
double b;
double c;
};
int main()
{
std::cout << std::boolalpha; // 输出 true 或 false,而不是 1 或 0
std::cout << isSmall(int) << '\n'; // true
double d {};
std::cout << isSmall(d) << '\n'; // true
std::cout << isSmall(S) << '\n'; // false
return 0;
}
补充说明……
这里使用函数式预处理宏,以便参数既可以是对象,也可以是类型名(C++ 函数不允许将类型作为参数传入)。
不过,很难判断类类型对象是否有初始化成本。最好假设大多数标准库类都有初始化成本,除非你确定它们没有。
提示
如果类型 T 满足 sizeof(T) <= 2 * sizeof(void*) 且没有额外的初始化成本,那么复制它的代价很低。
对于函数参数,大多数情况下优先使用 std::string_view 而不是 const std::string&
现代 C++ 中经常遇到一个问题:编写带字符串参数的函数时,参数类型应该是 const std::string& or std::string_view?
大多数情况下, std::string_view 是更好的选择,因为它能高效处理更广泛的实参类型。 一个 std::string_view 参数还允许调用者传入子字符串,而无需先将子字符串复制到新的 string 中。
void doSomething(const std::string&);
void doSomething(std::string_view); // 大多数情况下优先使用这种方式
有几种情况下使用 const std::string& 参数可能更合适:
- 如果使用 C++14 或更早版本,
std::string_view不可用。 - 如果函数需要调用接受 C 风格字符串或
std::string参数的其他函数,那么const std::string&可能更合适,因为std::string_view不保证以空字符结尾(C 风格字符串函数通常要求这一点),并且转换回std::string的效率不高。
最佳实践
除非函数调用需要 C 风格字符串或 std::string 参数,否则优先使用 std::string_view(按值传递)传递字符串,而不是 const std::string&。
为什么 std::string_view 参数比 const std::string& 更高效 进阶
在 C++ 中,字符串实参通常是 std::string、std::string_view 或 C 风格字符串/字符串字面量。
一些提醒:
- 如果实参类型与对应参数类型不匹配,编译器会尝试将实参隐式转换为参数类型。
- 转换值会创建转换后类型的临时对象。
- 创建(或复制)一个
std::string_view成本很低,因为std::string_view不会复制它所查看的字符串。 - 创建(或复制)一个
std::string可能成本很高,因为每个std::string对象都会复制字符串。
下面的表格展示了传递每种类型时会发生什么:
| 实参类型 | std::string_view 参数 | const std::string& 参数 |
|---|---|---|
| std::string | 低成本转换 | 低成本引用绑定 |
| std::string_view | 低成本复制 | 转换为 std::string 的高成本显式转换 |
| C 风格字符串 / 字符串字面量 | 低成本转换 | 高成本转换 |
使用 std::string_view 值参数时:
- 如果传入
std::string实参,编译器会将其转换为成本很低的std::string_view,因此没有问题。 - 如果传入
std::string_view实参,编译器会将实参复制到参数中,成本很低,因此没有问题。 - 如果传入 C 风格字符串或字符串字面量,编译器会将其转换为成本很低的
std::string_view,因此这样做没有问题。
可以看到,std::string_view 能以较低成本处理这三种情况。
使用 const std::string& 引用参数时:
- 如果传入
std::string实参,参数会以引用绑定到实参,成本很低,因此没有问题。 - 如果传入
std::string_view实参,编译器会拒绝隐式转换并产生编译错误。可以使用static_cast显式转换为std::string,但这种转换成本很高(因为std::string会复制当前查看的字符串)。转换完成后,参数会以引用绑定到结果,绑定本身成本很低;但为了转换已经付出了复制成本,因此并不理想。 - 如果传入 C 风格字符串或字符串字面量,编译器会将其隐式转换为
std::string,成本很高,因此也不理想。
因此,const std::string& 参数只能低成本地处理 std::string 实参。
用代码表示如下:
#include <iostream>
#include <string>
#include <string_view>
void printSV(std::string_view sv)
{
std::cout << sv << '\n';
}
void printS(const std::string& s)
{
std::cout << s << '\n';
}
int main()
{
std::string s{ "Hello, world" };
std::string_view sv { s };
// 传给 `std::string_view` 参数
printSV(s); // 正确:从 std::string 转换为 std::string_view,成本很低
printSV(sv); // 正确:复制 std::string_view,成本很低
printSV("Hello, world"); // 正确:C 风格字符串字面量转换为 std::string_view,成本很低
// 传给 `const std::string&` 参数
printS(s); // 正确:绑定到 std::string 实参,成本很低
printS(sv); // 编译错误:无法将 std::string_view 隐式转换为 std::string
printS(static_cast<std::string>(sv)); // 不推荐:创建 std::string 临时对象的成本很高
printS("Hello, world"); // 不推荐:创建 std::string 临时对象的成本很高
return 0;
}
此外,还要考虑函数内部访问参数的成本。由于 std::string_view 参数是普通对象,可以直接访问它所查看的字符串。访问 std::string& 参数则需要先经过额外一步找到被引用对象,之后才能访问字符串。
最后,如果要传入现有字符串(任意类型)的子字符串,创建一个 std::string_view 子字符串并将其低成本传给 std::string_view 参数。相比之下,将子字符串传给 const std::string& 成本更高,因为子字符串最终必须复制到引用参数所绑定的 std::string 中。