引用

是什么，为什么存在

引用（reference）让一个表达式直接指代已经存在的对象或函数。对引用读写，就是对它所绑定实体读写；引用不是一份独立副本，也不是负责释放资源的所有者。

左值引用（lvalue reference） 写作 T&，通常绑定到左值。 右值引用（rvalue reference） 写作 T&&，可以绑定到右值，让重载区分「继续使用的对象」和「资源可被复用的对象」。两者都是引用，但绑定规则和参与重载的方式不同。

引用解决的是接口中的间接访问问题。函数可以通过 T& 修改调用方对象，通过 const T& 只读访问对象，也可以返回 T&，让调用方继续操作容器元素或对象成员。运算符重载、范围循环、移动语义和泛型转发都会遇到引用。

引用在一个有效程序中必须指向有效对象或函数，初始化后不能改绑。给引用赋值时，变化的是所绑定对象，而不是引用与对象之间的关系。这个约束让必需参数的接口比裸指针少一种空值状态，但不会消除悬空风险。

引用和所有权是两条不同的轴。const Widget& 只限制通过这条访问路径能做什么，不说明 Widget 由谁拥有，也不保证它能活到引用最后一次使用。任何保存引用的设计都需要单独写明所有者和有效期。

工作原理

声明引用时，& 或 && 属于声明符。引用变量必须初始化；参数与函数返回类型只是在声明时没有具体绑定，实际调用和返回仍会执行引用初始化。语言不规定引用是否占用独立存储，因此不要把它描述成「一定就是一个指针」。

引用初始化根据引用类型、初始化表达式的类型和表达式的值类别决定能否直接绑定。常见规则可以先记成下面这张表；类类型的用户定义转换和基类子对象还会加入更多候选。

值类别属于表达式，不属于对象。每个表达式最终是 lvalue、xvalue 或 prvalue 之一；lvalue 和 xvalue 合称 glvalue，xvalue 和 prvalue 合称 rvalue。变量名表达式是 lvalue，即使该变量声明成 T&&。

std::move(value) 大致把表达式转换为 xvalue，不会自行移动资源。之后的初始化或函数调用才会进行重载决议（overload resolution），被选中的操作也可能复制。移动语义的完整资源契约属于 cpp/move-semantics。

const T& 和 T&& 直接绑定某些临时对象时，可以把该临时对象的生命周期延长到引用的生命周期。这个规则有明确边界：引用参数所绑定的临时对象通常只活到包含函数调用的完整表达式结束；把该参数再返回，不会把延长效果传给调用方。

参数表达的是调用约定

参数类型应该先表达语义，再考虑复制成本。小型、便宜复制的值通常按值传递；const T& 适合只读借用较大对象；T& 表示函数会修改一个必需对象。可选对象通常用指针或可选值表示，因为引用没有合法的空状态。

返回引用把同一份生命周期义务交给调用方。返回容器元素或对象成员可以是合理接口，但前提是拥有它的容器或对象仍存活，而且后续操作没有让元素地址失效。无法清楚保证这一点时，返回值通常更稳妥。

示例

下面四个示例依次展示别名与形参、引用返回、值类别重载和转发引用。所有输出都由 GCC 13.3 使用 -std=c++23 编译并实际运行得到。

别名和参数意图

invoice 与 total 指代同一个整数，所以通过任一名称修改都能从另一名称观察到。label 直接绑定到临时字符串，其生命周期延长到 label 的作用域结束。

&invoice == &total 比较后得到 true，因为对引用取地址会取得所绑定对象的地址。执行 invoice = another_total 只会把另一个整数的值写入 total，不会让 invoice 改绑。

add_fee() 的 int& 明确允许修改调用方对象。label_size() 只读访问字符串，但对这种很小的演示并没有性能结论；是否按引用传递仍应依据真实类型和接口语义决定。

返回容器中的对象

Catalog::at() 提供可修改和只读两个重载。返回的是 names_ 中已有字符串的引用，因此修改返回值会直接修改目录。

#include <cstddef>
#include <iostream>
#include <string>
#include <utility>
#include <vector>

class Catalog {
public:
    explicit Catalog(std::vector<std::string> names)
        : names_(std::move(names)) {}

    std::string& at(std::size_t index) {
        return names_.at(index);
    }

    const std::string& at(std::size_t index) const {
        return names_.at(index);
    }

private:
    std::vector<std::string> names_;
};

void archive_first(Catalog& catalog) {
    catalog.at(0) = "archived";
}

void print_first(const Catalog& catalog) {
    std::cout << catalog.at(0) << '\n';
}

int main() {
    Catalog catalog({"active", "queued"});
    std::string& first = catalog.at(0);
    archive_first(catalog);
    std::cout << first << '\n';
    print_first(catalog);
}

archived
archived

first 的有效期受 catalog 及其内部 std::vector 约束。销毁 catalog 后使用它会悬空；可能重新分配 vector 存储的操作也会使已有元素引用失效。at() 的边界检查不提供生命周期保护。

const 成员重载防止调用方通过 const Catalog& 取得可修改引用。它不把底层字符串永久变成 const，通过其他合法的非 const 路径仍可修改同一对象。

观察表达式的值类别

下面的重载只打印所选择的路径，不会从字符串移动。最后两次调用说明：变量 slot 的类型是 std::string&&，但名称表达式 slot 是 lvalue。

#include <iostream>
#include <string>
#include <utility>

void inspect(std::string& value) {
    std::cout << "mutable lvalue: " << value << '\n';
}

void inspect(const std::string& value) {
    std::cout << "const lvalue: " << value << '\n';
}

void inspect(std::string&& value) {
    std::cout << "rvalue: " << value << '\n';
}

int main() {
    std::string queued = "queued";
    const std::string fixed = "fixed";

    inspect(queued);
    inspect(fixed);
    inspect(std::string{"temporary"});

    std::string&& slot = std::string{"named"};
    inspect(slot);
    inspect(std::move(slot));
}

mutable lvalue: queued
const lvalue: fixed
rvalue: temporary
mutable lvalue: named
rvalue: named

声明类型与表达式类别必须分开推理。函数内部有名字的右值引用形参同样是 lvalue；只有在确实允许复用资源时，才把它转换为 xvalue。

这里的 std::move(slot) 只改变重载选择。inspect(std::string&&) 没有把参数用于构造或赋值另一个字符串，所以这次运行后 slot 的字符仍然存在；这不是所有移动操作的保证。

保留调用方的值类别

模板参数推导中的无 cv 限定 T&& 是 转发引用（forwarding reference） 。左值实参会让 T 推导为左值引用，随后 引用折叠（reference collapsing） 使形参仍为左值引用；右值实参则得到右值引用。

#include <iostream>
#include <string>
#include <utility>

struct Ticket {
    std::string name;
};

void dispatch(const Ticket& ticket) {
    std::cout << "borrowed: " << ticket.name << '\n';
}

void dispatch(Ticket&& ticket) {
    std::cout << "transferable: " << ticket.name << '\n';
}

template<class T>
void relay(T&& ticket) {
    dispatch(std::forward<T>(ticket));
}

int main() {
    Ticket queued{"queued"};
    relay(queued);
    relay(Ticket{"new"});
}

borrowed: queued
transferable: new

ticket 在 relay() 函数体中是有名字的变量，因此表达式本身是 lvalue。std::forward<T>(ticket) 根据推导出的 T 有条件地恢复调用方的类别；把它替换成 std::move(ticket) 会把调用方传入的普通左值也当成可消耗对象。

并非每个 T&& 都是转发引用。void take(Ticket&&) 的类型已经具体确定，const T&& 带有 cv 限定，而类模板成员中的 T&& 若 T 已由类实例确定，也只是普通右值引用。

陷阱

把赋值误认为改绑

修复： 需要可改绑观察者时使用指针，或在标准库容器中使用 std::reference_wrapper<T>。后者可以重新赋值并保存到容器，但仍不拥有对象，也仍可能悬空。

返回局部对象或临时对象的引用

修复： 默认按值返回，让复制消除和移动规则处理结果。确实返回引用时，在接口中标出所有者，并测试所有者销毁、容器重新分配和元素删除后的失效边界。

把 const& 当成生命周期保险

修复： 沿引用追溯到最终拥有对象，不要只检查最后一次绑定。跨异步任务、回调或容器保存引用前，要证明所有者活得更久；做不到时就复制值或传递拥有型句柄。

把所有 T&& 都当成转发引用

修复： 在每个模板入口写出 T 的推导结果与折叠后的形参类型。只有透明包装器使用 std::forward<T>；明确接收资源的具体右值引用按其所有权契约处理。

机械地把所有输入改成 const&

修复： 先决定函数是读取、修改、保存还是接管参数，再选择按值、const T&、T& 或拥有型参数。性能选择需要基于真实类型和调用路径，不要从「引用总能避免复制」推导结论。

忘记元素引用的失效规则

修复： 查明具体容器和操作的失效保证，并把引用的使用限制在稳定区间。长期标识元素时，考虑稳定所有权、索引或经过校验的句柄，但不要假定换成指针就能修复生命周期。

延伸阅读

• C++23 工作草案：引用声明
• C++23 工作草案：引用初始化
• C++23 工作草案：值类别
• C++23 工作草案：函数调用中的模板参数推导
• C++ Core Guidelines：参数传递