Reference initialization

将引用绑定到对象。

语法

非列表初始化

普通列表初始化 (始于 C++11)

指定列表初始化 (C++20 起)

对 T 的引用可以用 T 类型的对象、 T 类型的函数，或可隐式转换为 T 的对象进行初始化。一旦初始化后，引用不能被重新绑定（更改）以指向其他对象。

引用在以下情况下被初始化：

说明

定义

对于两种类型 T1 和 T2 ：

• 给定 T1 和 T2 的 cv 非限定版本分别为 U1 和 U2 ，若 U1 与 U2 相似 ，或 U1 是 U2 的 基类 ，则称 T1 与 T2 引用相关 。
• 若类型“指向 T2 的指针”的纯右值可通过标准转换序列转换为类型“指向 T1 的指针”，则称 T1 与 T2 引用兼容 。

初始化规则

对于非列表引用初始化，给定 目标 的类型为 U ，该引用要么 直接绑定 到目标，要么绑定到从 目标 转换而来的类型 T 的值。首先考虑直接绑定，其次考虑间接绑定，如果两种绑定方式均不可用，则程序非良构。

在所有使用两种类型的引用兼容关系来确定引用绑定有效性，且标准转换序列将不合规的情况下，需要此类绑定的程序是不合规的。

直接绑定

若满足以下所有条件：

• 要初始化的引用是一个左值引用。
• target 是一个非 位域 的左值。
• T 与 U 是引用兼容的。

随后引用将绑定到 target ，或绑定到其对应的基类子对象：

double d = 2.0;
double& rd = d;        // rd 引用 d
const double& rcd = d; // rcd 引用 d
struct A {};
struct B : A {} b;
A& ra = b;             // ra 引用 b 中的 A 子对象
const A& rca = b;      // rca 引用 b 中的 A 子对象

否则，如果满足以下所有条件：

• 待初始化的引用是一个左值引用。
• U 是一个类类型。
• T 与 U 不存在引用关联。
• target 可转换为类型 V 的左值，且 T 与 V 引用兼容。

然后引用绑定到转换结果的左值，或其适当的基类子对象：

struct A {};
struct B : A { operator int&(); };
int& ir = B(); // ir 引用 B::operator int& 的返回结果

否则，如果要初始化的引用是左值引用，且 T 不是 const 限定或具有 volatile 限定，则程序非良构：

double& rd2 = 2.0; // 错误：不是左值且引用不是常量
int i = 2;
double& rd3 = i;   // 错误：类型不匹配且引用不是常量

否则，如果满足以下所有条件：

• target 属于以下任一类别：

• T 与 U 引用兼容。

随后引用绑定到 target ，或其对应的基类子对象：

struct A {};
struct B : A {};
extern B f();
const A& rca2 = f(); // 绑定到B右值的A子对象
A&& rra = f();       // 同上
int i2 = 42;
int&& rri = static_cast<int&&>(i2); // 直接绑定到i2

否则，如果满足以下所有条件：

• U 是一个类类型。
• T 与 U 无引用关联。
• target 可转换为类型 V 的值 v ，使得 T 与 V 引用兼容，其中 v 属于以下任意类别：

随后引用将绑定到转换结果，或绑定到其适当的基类子对象：

struct A {};
struct B : A {};
struct X { operator B(); } x;
const A& r = x; // 绑定到转换结果的A子对象
B&& rrb = x;    // 直接绑定到转换结果

间接绑定

如果直接绑定不可用，则会考虑间接绑定。在这种情况下， T 不能与 U 形成引用关联。

如果 T 或 U 是类类型，则按照通过用户定义转换对 T 类型对象进行 复制初始化 的规则来考虑用户定义转换。如果对应的非引用复制初始化将导致程序非良构，则此程序非良构。随后，如针对非引用 复制初始化 所述，调用转换函数的结果将用于直接初始化该引用。在此直接初始化过程中，不再考虑用户定义转换。

const std::string& rs = "abc"; // rs 引用从字符数组临时拷贝初始化的对象
const double& rcd2 = 2;        // rcd2 引用值为 2.0 的临时对象
int i3 = 2;
double&& rrd3 = i3;            // rrd3 引用值为 2.0 的临时对象

临时对象的生命周期

当引用被绑定到临时对象或其子对象时，该临时对象的生存期将被延长以匹配引用的生存期（查看 临时对象生存期例外情况 ），其中临时对象或其子对象由以下表达式之一表示：

• 括号表达式 ( e ) ，其中 e 是这些表达式之一，
• 形式为 a [ n ] 或 n [ a ] 的 内置下标表达式 ，其中 a 是数组且为这些表达式之一，
• 形式为 e. m 的 类成员访问表达式 ，其中 e 是这些表达式之一且 m 指代对象类型的非静态数据成员，
• 形式为 e. * mp 的 指向成员操作 ，其中 e 是这些表达式之一且 mp 是指向数据成员的指针，
• 不涉及用户定义转换的 const_cast 、 static_cast 、 dynamic_cast 或 reinterpret_cast 转换，将其中一个表达式转换为指代操作数所指定对象或其完整对象/子对象的泛左值（ 显式转换表达式 会被解释为这些转换的序列），
• 形式为 cond ? e1 : e2 的 条件表达式 且为泛左值，其中 e1 或 e2 是这些表达式之一，或
• 形式为 x, e 的 内置逗号表达式 且为泛左值，其中 e 是这些表达式之一。

此生命周期规则存在以下例外情况：

• 函数调用中绑定到引用参数的临时对象，其生命周期持续到包含该函数调用的完整表达式结束为止：如果函数返回一个引用，且该引用的生存期超过完整表达式，则它将变成一个悬垂引用。

struct A
{
    int&& r;
};
A a1{7}; // OK, lifetime is extended
A a2(7); // well-formed, but dangling reference

通常来说，临时对象的生命周期无法通过"传递"进一步延长：从绑定该临时对象的引用变量或数据成员初始化的第二个引用，不会影响其生命周期。

注释

引用仅在函数参数声明、函数返回类型声明、类成员声明以及带有 extern 说明符时可以不包含初始化式。

在 CWG issue 1696 解决之前，允许在构造函数 初始化列表 中将临时对象绑定到引用成员，且该临时对象仅持续到构造函数退出为止，而非与对象生命周期一致。自 CWG 1696 起，此类初始化被视为非良构，尽管许多编译器仍支持该行为（clang 是显著例外）。

示例

#include <sstream>
#include <utility>
struct S
{
    int mi;
    const std::pair<int, int>& mp; // 引用成员
};
void foo(int) {}
struct A {};
struct B : A
{
    int n;
    operator int&() { return n; }
};
B bar() { return B(); }
//int& bad_r;      // 错误：无初始化器
extern int& ext_r; // 正确
int main()
{
//  左值
    int n = 1;
    int& r1 = n;                    // 指向对象 n 的左值引用
    const int& cr(n);               // 引用可具有更多 cv 限定
    volatile int& cv{n};            // 可使用任意初始化语法
    int& r2 = r1;                   // 指向对象 n 的另一个左值引用
//  int& bad = cr;                  // 错误：cv 限定更少
    int& r3 = const_cast<int&>(cr); // 需要 const_cast
    void (&rf)(int) = foo; // 函数左值引用
    int ar[3];
    int (&ra)[3] = ar;     // 数组左值引用
    B b;
    A& base_ref = b;        // 指向基类子对象的引用
    int& converted_ref = b; // 指向转换结果的引用
//  右值
//  int& bad = 1;        // 错误：无法将左值引用绑定到右值
    const int& cref = 1; // 绑定到右值
    int&& rref = 1;      // 绑定到右值
    const A& cref2 = bar(); // 指向 B 临时对象中 A 子对象的引用
    A&& rref2 = bar();      // 同上
    int&& xref = static_cast<int&&>(n); // 直接绑定到 n
//  int&& copy_ref = n;                 // 错误：无法绑定到左值
    double&& copy_ref = n;              // 绑定到值为 1.0 的右值临时对象
//  临时对象生命期限制
//  std::ostream& buf_ref = std::ostringstream() << 'a';
                     // ostringstream 临时对象已绑定到 operator<< 的左操作数
                     // 但其生命期在分号处结束，因此 buf_ref 成为悬垂引用
    S a {1, {2, 3}}; // 临时 pair {2, 3} 绑定到引用成员 a.mp
                     // 其生命期被延长以匹配对象 a 的生命期
    S* p = new S{1, {2, 3}}; // 临时 pair {2, 3} 绑定到引用成员 p->mp
                             // 但其生命期在分号处结束，p->mp 成为悬垂引用
    delete p;
    // 模拟应用于以下变量的 [[maybe_unused]]：
    [](...){}
    (
        cv, r2, r3, rf, ra, base_ref, converted_ref,
        a, cref, rref, cref2, rref2, copy_ref, xref
    );
}

缺陷报告

以下行为变更缺陷报告被追溯应用于先前发布的C++标准。

另请参阅

• 构造函数
• 转换构造函数
• 拷贝赋值
• 拷贝构造函数
• explicit
• 初始化
  • 常量初始化
  • 拷贝初始化
  • 直接初始化
  • 列表初始化
• 移动赋值
• 移动构造函数
• new