C++ 引用类型（左值引用、const 引用、右值引用、universal 引用）

引用类型

引用：引用就是声明具名变量，也即是对象或函数的别名。

引用必须被初始化为指代一个有效的对象或函数，T 类型的对象、T 类型的函数 或 可隐式转换为 T 类型的对象，可以用于初始化 T 类型的引用。
引用一旦初始化，则不能更改使之引用另一对象。
不存在 void 的引用，也不存在引用的引用
引用不是对象，不必占用内存。但是若需要分配内存以实现所需语义（例如，引用类型的非静态数据成员通常会增加类的大小），编译器会为其分配内存。
因为引用不是对象，故不存在引用的数组，不存在指向引用的指针，不存在引用的引用。

int& a[1];  // 错误
int& *p;    // 错误
int& &r;    // 错误

1. 左值引用

int& lr = i;
int& lr(i);

左值引用可用于建立即存对象的别名，也即是绑定到左值

    int i = 0;
    int& lr = i;    // int型引用 lr 绑定到了对象 i 上 
    
    lr += 1;        // 通过引用 lr 修改了对象 i

    int& lr = 1;    // 错误，非常量左值引用不能绑定到右值上

指针和引用都是地址的概念，但是指针有空指针的说法，引用不能为空，初始化引用必须绑定到即存的对象上。

    int* p = nullptr;   // 正确，指针可以为空指针 
    int& lr;            // 错误，引用不能为空

左值引用可用于在函数调用中实现按引用传递语义

void func(int& i)
{
    i += 5;     // i 调用方与传入的对象同一对象 
}

当函数的返回值是左值引用时，函数调用表达式成为左值表达式

char& get_char(string& s, size_t n) // 函数返回值为左值引用时，函数表达式成为左值表达式 
{
    return s.at(n);
}

int main()
{
    string str = "hello world";
    get_char(str, 2) = '~';      // 函数调用是左值，可被赋值 
    
    cout << str << endl;         // 输出 "he~lo world"
}

2. const 引用

const int& cr = i;
const int& cr(i);

const 引用是左值引用的一种
const 引用可以作为临时变量的引用，延长临时对象声明周期。也即是const 引用既可以绑定到左值，又可以绑定到右值。

    int i = 1;
    const int& j = i;   // const 引用绑定到 对象 i (左值) 上
    const int& k = 1;   // const 引用绑定到 字面量 (右值) 上

不能通过 const 引用，修改被绑定的对象。

    int i = 1;
    const int& j = i;
    j = 2;  // 错误，无法通过 const 引用修改被绑定的对象

3. 右值引用

int&& rr = 1;
int&& rr(1);

右值引用可用于为临时对象延长生命周期，也即是绑定到右值，并且可以通过右值引用修改临时对象。

左值引用和右值引用必须在声明的时候立即初始化，因为引用本身并不拥有所绑定对象的内存，只是该对象的一个别名。通过右值引用的声明，该右值又“重获新生”，其生命周期变得和右值引用类型变量的生命期一样长，只要该变量还活着，该右值临时量将会一直存活下去。

    int i = 1;
    int&& rr = i + i;   // 右值引用 延长右值声明周期 
    rr += 3;            // 允许通过右值引用修改被绑定的右值

具名的右值引用是左值，不具名的右值引用是右值。
需要注意的是，右值引用绑定的表达式是右值，但是右值引用类型可能是左值，也可能是右值。

void PrintValue(int& i) 
{
    cout << "lvalue: " << i << " " << &i <<endl;
}

void PrintValue(int&& i)
{
    cout << "rvalue: " << i << " " << &i << endl;
}

void Forward(int&& i)
{
    PrintValue(i);
}

int main()
{
    int i = 0;
    PrintValue(i);  // 验证 i 为 lvalue
    PrintValue(10); // 验证 10 为 rvalue
    
    Forward(10);    // 通过 Forward 转发，验证了具名的右值引用为 lvalue 
    
    return 0;
}

引用折叠

容许通过模板或 typedef 中的类型操作构成引用的引用，这种情况下适用引用折叠（reference collapsing）规则：右值引用的右值引用折叠成右值引用，所有其他组合均折叠成左值引用

即右 + 右 = 右，其余组合均为左值引用

typedef int&  lref;
typedef int&& rref;
int n;
lref&  r1 = n; // r1 的类型是 int&
lref&& r2 = n; // r2 的类型是 int&
rref&  r3 = n; // r3 的类型是 int&
rref&& r4 = 1; // r4 的类型是 int&&

4. universal 引用

如果声明变量或者参数具有 T&& 的形式，并且 T 需要经过类型推导，那么就是综合引用（universal reference）

例一：

// 调用 PrintValue 需要经过 T 的类型推导，所以下例是 universal reference
// 传入的 val 为左值时，T&& 为左值引用
// 传入的 val 为右值时，T&& 为右值引用 
template <typename T>
void PrintValue(T&& val)
{
    cout << "is lvalue reference : " << is_lvalue_reference<T&&>::value << endl;
    cout << "is rvalue reference : " << is_rvalue_reference<T&&>::value << endl;
    cout << endl;
}

int main()
{
    int i = 1;
    PrintValue(i);  // i 为左值，左值引用 
    
    int& lr = i;
    PrintValue(lr); // lr 为左值，左值引用 
    
    int&& rr = 3;
    PrintValue(rr); // rr 为左值（具名右值引用类型为左值），左值引用 
    
    PrintValue(15); // 非字符串字面量为右值，右值引用 
    
    PrintValue("hello world");  // 字符串字面量为左值，左值引用 
    
    PrintValue(move(i));        // move(val) 返回右值，右值引用 
}

例二：
形如 auto&& r = val; 需要通过 val 的值去具体推导，所以也是 universal reference

int main()
{
    int i = 0;
    auto&& r1 = i;          // 左值引用 
    
    auto&& r2 = move(i);    // 右值引用 
    
    return 0;
}

其余的，不满足 T&& val，或者 T 不需要通过推导得出的，都不是 universal reference
例一：
形如 const T&& val

// const T&& val，不再满足 T&& val 格式
// const T&& val 实际上是 "不可修改" 的右值引用 
template <typename T>
void PrintValue(const T&& val)
{
    cout << "is lvalue reference : " << is_lvalue_reference<T&&>::value << endl;
    cout << "is rvalue reference : " << is_rvalue_reference<T&&>::value << endl;
    cout << endl;
}

int main()
{
    PrintValue(10); // 传入右值，正确 
    
    int i = 1;
    PrintValue(i);  // 传入左值，错误 
}

例二：
非 T&& val

// vector<T>&& 就是右值引用，此时 T 的具体类型并不会对其引用类型有影响 
template<typename T>
void PrintValue(vector<T>&& val)
{
    cout << "is lvalue reference : " << is_lvalue_reference<vector<T>&&>::value << endl;
    cout << "is rvalue reference : " << is_rvalue_reference<vector<T>&&>::value << endl;
    cout << endl;   
} 

int main()
{
    PrintValue((vector<int>){1, 2, 3}); // 传入 vector<int> 型右值，正确 
    
    vector<int> vec = {1, 2, 3};
    PrintValue(vec);    // 传入左值，错误 
}

例三：
T&& val，类型 T 不需推导

// 类模板中的 函数调用形参 T&& val 不能看作是 universal reference
// 因为在类模板被实例化时，类型 T 已经确定了，此时 PrintValue 的形参类型也已经确定了 
template <typename T>
class Test
{
public:
    void PrintValue(T&& val)
    {
        cout << "is lvalue reference : " << is_lvalue_reference<vector<T>&&>::value << endl;
        cout << "is rvalue reference : " << is_rvalue_reference<vector<T>&&>::value << endl;
        cout << endl;
    }   
};

int main()
{
    Test<int> t;        // 类型 T 确定为 int，此时 PrintValue(int&& val)，无需类型推导 
    t.PrintValue(1);    // 传入右值，正确 
    
    int i = 2;
    t.PrintValue(i);    // 传入左值，错误 
}

5. 悬垂引用

尽管引用一旦初始化，就始终指代一个有效的对象或函数，但有可能被指代对象的生命周期结束，但引用仍保持可访问状态（悬垂）。访问这种引用是未定义行为。一个常见例子是返回自动变量的引用的函数：

int& func_lref()
{
    int i = 10;
    cout << "func_lref() " << i << " " << &i << endl;
    return i;   // 退出 i 的作用域，资源被回收 
}

int main()
{
    int& r1 = func_lref();              // 悬垂引用 
    cout << r1 << " " << &r1 << endl;   // 未定义行为：从悬垂引用读取 
    
    int j = func_lref();                // 未定义行为：从悬垂引用复制初始化 
    cout << j << " " << &j << endl;
}