C++11/14/17 学习的第一篇：左值、右值、左值引用、右值引用、移动语义、完美转发。
左值和右值
- 左值是可以放在赋值号左边可以被赋值的值，它必须要在内存中有实体。
- 右值当在赋值号右边取出值赋给其他变量的值，它可以在内存也可以在寄存器。
总的来讲，左值可以被赋值或者修改，而右值不能。
下面是一些例子：
int a, b, *p;
const int c = 7;
// 【正确】a 为左值，7 为右值
a = 7;
// 【错误】7 为常量，故为右值。右值不能被赋值。
7 = a;
// 【错误】j * 4 为表达式，故为右值。右值不能被赋值。
b * 4 = 7;
// 【正确】*p 为取址，是左值。
*p = a;
// 【正确】等号左边的表达式返回的是左值。
((a < 3) ? a : b) = 7;
// 【错误】ci 为常量，故为右值。右值不能被赋值。
c = 9;
左值引用右值引用
- 左值引用相当于变量的别名。当它引用另一个变量时，指向的还是同一个地址。
- 右值引用与左值引用类似，不过它引用的是一个右值。
总的来讲，左值引用只能引用左值，右值引用只能引用右值。
下面是一些例子：
int a = 100;
// 【正确】a 为左值，b 可以对其左值引用
int& b = a;
// 【错误】a++ 为右值，无法对其左值引用
int& c = a++; // error
// 【正确】200 为右值，d 可以对其右值引用
int&& d = 100;
// 【错误】a 为左值，无法对其右值引用
int&& e = a; // error
// 【正确】这是特例。由于左侧为常量，故可以对右值进行左值引用
const int& f = 100;
左值可以通过转换来被右值引用。
下面是一些例子：
int a = 1000;
// 使用 std::move 转为右值引用
int&& b = std::move(a);
// 使用 static_cast 转为右值引用
int&& c = static_cast<int&&>(a);
// 使用 C 风格强转为右值引用
int&& d = (int&&)a;
// 使用 std::forwad<T&&> 为右值引用
int&& e = std::forward<int&&>(a);
移动语义
我们知道，对于 C++ 中的一个类，如果类中有类似指针的东西，那么在默认情况下，拷贝构造时仅仅复制了指针指向的地址，而不是新开辟一块内存存放指针指向的内容，这称为“浅拷贝”。与之相对的就是“深拷贝”。
浅拷贝会使多个实例公用同一个对象，造成安全性问题；而深拷贝尽管安全，却造成了巨大的资源开销。
举个例子，小明和小红看电视。浅拷贝就是给了每人一个遥控器，两个人分别遥控电视时会产生冲突；深拷贝就是买了两台电视，各看各的，显得很浪费。最好的解决方法是一台电视一部遥控器，谁要看就把遥控器交给谁，这就是移动拷贝。
移动拷贝构造会使用移动语义，转移资源，相当于移交了资源的控制权。
下面是一个例子：
class class_a
{
public:
// 深拷贝构造函数
class_a(const class_a& b):
m_size(b.m_size)
{
m_data = new char[m_size];
memcpy(m_data, b.m_data, m_size);
}
// 移动拷贝构造函数
class_a(class_a&& b):
m_size(b.m_size),
m_data(b.m_data)
{
b.m_data =nullptr;
}
int m_size;
char* m_data;
};
// class_a(1000) 为右值，发移动拷贝构造
class_a a(class_a(1000));
move
move 可以将左值转换为右值引用。
例如对于上一节的类，我们有如下使用移动拷贝构造的方法：
class_a a(1000);
// a 为左值，通过 std::move(a) 转换为右值引用，发移动拷贝构造
class_a b(std::move(a));
move 的底层实现如下：
template <class _Ty>
_NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept {
return static_cast<remove_reference_t<_Ty>&&>(_Arg);
}
这是利用了引用的折叠规则
-
T& &、T& &&、T&& &折叠成T& -
T&& &&折叠成T&&
所以首先去掉所有引用，在加上右值引用，就实现了强制转换为右值引用的功能。
forward
我们有一个例子：
void func(class_b& rA) {
// 左值引用版本函数
std::cout << "lvalue " std::endl;
}
void func(class_b&& rA) {
// 右值引用版本函数
std::cout << "rvalue " std::endl;
}
// class_b(1000) 为右值，调用右值引用版本函数
func(class_b(1000));
class_b&& a = class_b(1000);
// a 为右值引用，但本身是左值，调用左值引用版本函数
func(a);
我们希望能找到一个方法，使得传入函数的为左引用时，函数内保持左引用；传入函数的为右引用时，函数内保持右引用。
我们首先要使函数既能接收左值引用，也能接收右值引用。万能引用恰好可以实现这一想法：
template<typename T>
void func(T&& a) {
};
然后我们使用 forward 保持原来的引用关系：
template<typename T>
void func(T&& a){
b = std::forward<T>(a);
}
forward 能够完美转发以下几种类型：
T&T&&const T&const T&&
forward 的底层实现如下：
template <class _Ty>
_NODISCARD constexpr _Ty&& forward(
remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvalue
return static_cast<_Ty&&>(_Arg);
}
template <class _Ty>
_NODISCARD constexpr _Ty&& forward(remove_reference_t<_Ty>&& _Arg) noexcept { // forward an rvalue as an rvalue
static_assert(!is_lvalue_reference_v<_Ty>, "bad forward call");
return static_cast<_Ty&&>(_Arg);
}
上面的实现将左值转换为左值或者右值引，下面的实现将右值转换为右值。
move 和 forward 都可以被 static_cast 替代，但前者会在编译期间进行类型检查，更加安全。
总结
- 浅拷贝存在安全性问题，深拷贝临时变量开销太大。
- 所以使用右值引用传递临时变量。
- 使用
move将左值变为右值引用。 - 使用
forward同时处理左值和右值引用。
Comments