引用类型
引用：引用就是声明具名变量，也即是 对象 或 函数 的别名。
- 引用必须被初始化为指代 一个有效的对象或函数，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;
}
网友评论