C++中 value category & move
原来我也只知道C++中有左值和右值，通过今天的学习才知道，C++中不光有左值和右值。
C++中有5种值类别，lvalue, rvalue, glvalue, xvalue, prvalue
- lvalue: 左值
- rvalue: 右值
- glvalue: generalized lvalue, 广义左值
- xvalue: expiring lvalue, 将亡值
- prvalue: prue rvalue, 纯右值
看到这些不要害怕，我们一点点来。
首先我们看下最熟悉的lvalue.
lvalue
左值是有标识符，可以取地址的表达式。 比如说：
变量，函数名，类的数据成员名
这些都是变量名嘛
返回左值引用的表达式，如 ++x, x = 1, cout << " "
字符串字面值，如"hello world"
值得注意的是，&, reference 其实是左值引用，我们在调用函数时，传递的参数是左值，编译器就会匹配函数参数是左值的那一个函数。
一个常量只能绑定到常左值引用，比如:
const int a = 1; // int& b = a; // 编译不过 const int& c = a;
prvalue
纯右值，是没有标识符，不可取地址的表达式，一般称之为临时对象
- 非引用类型的表达式，如x++, x+1, make_shared<int>(42)</int>
- 除字符串字面值之外的字面值，如 42, true
在C++11之前，右值可以绑定到常左值引用的参数，但是不可以绑定到非 常左值引用。 如:
// int& a = 1; // 编译不过 const int& a = 1;
在C++11，引入了右值引用，&&。这时我们就可以右值绑定到常右值引用，或者是非常右值引用了。
int&& a = 1; const int&& b = 1;
引入一种额外的引用类型当然增加了语言的复杂性，但也带来了很多优化的可能性。由于 C++ 有重载，我们就可以根据不同的引用类型，来选择不同的重载函数，来完成不同的行为。
void f(int& a) {
cout << "int&" << endl;
}
void f(int&& a) {
cout << "int&&" << endl;
}
int main(int argc, char const* argv[])
{
int a = 1;
f(a); // a 是一个左值，变量名
f(1); // 数字1是一个右值
return 0;
} 输出:
int& int&&
那f内的a是左值还是右值呢？ 都是左值，因为他们都是一个变量名。类型右值引用的变量是一个左值
xvalue
将亡值，也是一个右值
标准库里有一个move函数，std::move，它的作用是把一个左值引用强制转换成一个右值引用，并不改变其内容。
我们可以把move的返回值看成一个有名字的右值，为了跟无名的纯右值相区别，C++就把这种表达式叫做xvalue，xvalue也是不能取地址的。
插播一个生命周期
一个变量的生命周期在超出作用域时结束。如果一个变量代表一个对象，当然这个对象的生命周期也在那时结束。
那临时对象（prvalue）呢？
C++ 的规则是：一个临时对象会在包含这个临时对象的完整表达式估值完成后、按生成顺序的逆序被销毁，除非有生命周期延长发生。
我们先看一个没有生命周期延长的基本情况：
class shape {
public:
virtual ~shape() {}
};
class circle : public shape {
public:
circle() { cout << "circle()" << endl; }
~circle() { cout << "~circle()" << endl; }
};
class triangle : public shape {
public:
triangle() { cout << "triangle()" << endl; }
~triangle() { cout << "~triangle()" << endl; }
};
class result {
public:
result() { cout << "result()" << endl; }
~result() { cout << "~result()" << endl; }
};
result
process_shape(const shape& shape1,
const shape& shape2)
{
return result();
}
process_shape(circle(), triangle()); 输出:
triangle() circle() result() ~result() ~circle() ~triangle()
运行之后你可以看到，result 临时对象最后生成，最先被析构。
下面，我们用右值引用接收一下返回值，result&& r = process_shape(circle(), triangle());
triangle() circle() result() ~circle() ~triangle() ~result()
你会发现，result的生成还在原来的位置，但是析构被延迟到了最后。
我们在上一步的基础上在加上move, result&& r = move(process_shape(circle(), triangle()));
triangle() circle() result() ~result() ~circle() ~triangle()
输出又变回了原来的样子。
需要注意的是: 右值引用的声明周期延长只对 prvalue 有效，而对 xvalue无效。 如果由于某种原因，prvalue 在绑定到引用以前已经变成了 xvalue，那生命期就不会延长。不注意这点的话，代码就可能会产生隐秘的 bug。
移动
C++出现移动的意义是什么？
class A {
B b_;
C c_;
}; 对于这样的代码，从实际内存布局的角度，很多语言如 Java 和 Python 会在 A 对象里放 B 和 C 的指针（虽然这些语言里本身没有指针的概念）。 而 C++ 则会直接把 B 和 C 对象放在 A 的内存空间里。这种行为既是优点也是缺点。说它是优点，是因为它保证了内存访问的局域性，而局域性在现代处理器架构上是绝对具有性能优势的。说它是缺点，是因为复制对象的开销大大增加：在 Java 类语言里复制的是指针，在 C++ 里是完整的对象。这就是为什么 C++ 需要移动语义这一优化，而 Java 类语言里则根本不需要这个概念。
如何实现移动??
通常需要下面几步：
类应该有拷贝构造和移动构造（除非你只打算支持移动，不支持拷贝————如 unique_ptr）
可以参考我的文章 《C++手把手带你实现一个智能指针》
应该有 swap 成员函数，支持和另外一个对象快速交换成员
在你的对象的命名空间下，应当有一个全局的 swap 函数，调用成员函数 swap 来实现交换。
支持这种用***方便别人（包括你自己在将来）在其他对象里包含你的对象，并快速实现它们的 swap 函数。
实现通用的
operator=上面各个函数如果不抛异常的话，应当标为 noexcept。
我写了一个例子，可以参考一下，如果有问题还请指出来，我也是在学习过程中。
class A
{
public:
A(int a = 1) : m_a(a) {}
~A() {}
private:
int m_a;
};
class B
{
public:
B() {}
B(A a) : m_a(a) {}
~B() {}
void swap(B& rhs) noexcept {
using std::swap;
swap(m_a, rhs.m_a);
}
B(const B& b) noexcept {
m_a = b.m_a;
}
B(B&& rhs) noexcept {
swap(rhs);
}
B& operator=(const B& rhs) noexcept {
m_a = rhs.m_a;
return *this;
}
B& operator=(B&& rhs) noexcept {
swap(rhs);
return *this;
}
private:
A m_a;
};
void swap(B& a, B& b) {
a.swap(b);
}
int main()
{
B b(100);
B b1 = b, b2;
b2 = b;
B b3(move(b));
B b4;
b4 = move(b2);
B b5(200), b6(1000);
swap(b5, b6);
} 不要返回临时变量的引用
刚学C++的时候，我就出现过把函数内的局部变量返回的情况，函数的返回值是一个引用。
比如说:
class A
{
};
A& f() { // 编译不过
return A();
} 因为 f() 函数内返回的A()，这个临时变量在f() 调用结束后就被销毁了，返回一个指向本地对象的引用属于未定义行为。
所以正确的写法应该是把& 去掉，A& f()改为A f(), C++11之前，编译器会自动把这个临时对象拷贝一份作为函数的返回值传递回来。
除非编译器发现可以做返回值优化（named return value optimization，或 NRVO)，能把对象直接构造到调用者的栈上。
从 C++11 开始，返回值优化仍可以发生，但在没有返回值优化的情况下，编译器将试图把本地对象移动出去，而不是拷贝出去。
返回值优化不需要我们去改move, 写了move反而弄巧成拙，会取消返回值优化。
class A
{
public:
A() { cout << "A" << endl; }
A(const A& a) { cout << "A&" << endl; }
A(A&& a) { cout << "A&&" << endl; }
};
A f() {
return A();
}
A f2() {
return move(A());
}
int main()
{
f();
cout << "---------------" << endl;
f2();
return 0;
} 输出:
A --------------- A A&&
f()，编译器对返回值进行了优化，对象直接被构造到调用者的栈上（没有被拷贝和搬移）,
f2()，move 破坏了返回值优化，相对于f()，对象还被多搬移了一次，这个搬移属实没必要。
完美转发
void f2(int& a) {
cout << "f2 int&" << endl;
}
void f2(int&& a) {
cout << "f2 int&&" << endl;
}
void f(int& a) {
cout << "int&" << endl;
}
void f(int&& a) {
cout << "int&&" << endl;
f2(a);
}
int main()
{
int a = 1;
f(move(a));
return 0;
} 输出:
int&& f2 int&
我们之前有说到，void f(int&& a)，a在f的函数体内又变成了左值，因为它是一个变量，那么我们怎么才能保证a原来是右值，进入函数体以后还是一个右值呢？
这就用到了完美转发，std::forward(), 我们把上述代码的
void f(int&& a) {
cout << "int&&" << endl;
f2(a);
} 改成
void f(int&& a) {
cout << "int&&" << endl;
f2(forward<int>(a));
} 输出:
int&& f2 int&&
完美转发，forward是一个函数模板，我们则需要把类型传递进去，这个例子传递的是一个int类型。
好了，值类型和搬移先说到这里了，如果文章有错误的地方还请给我指出来，大家一起进步嘛。
如果觉得对你有帮助的话请@程序员杨小哥 点个赞，谢谢！
