C++ 11右值引用、移动语义和完美转发
左值、右值
左值是指表达式结束后依然存在的持久化对象，右值是指表达式结束时就不再存在的临时对象。所有的具名变量或者对象都是左值，而右值不具名。很难得到左值和右值的真正定义，但是有一个可以区分左值和右值的便捷方法：看能不能对表达式取地址，如果能，则为左值，否则为右值。
int i=0;// i是左值， 0是右值
class Base
{
public:
int base;
};
Base getBase()
{
return Base();
}
Base b = Base(); // b是左值 getBase()的返回值是右值（临时变量）左值引用、右值引用
C++98中的引用很常见了，就是给变量取了个别名，在C++11中，因为增加了右值引用(rvalue reference)的概念，所以c++98中的引用都称为了左值引用(lvalue reference)。C++11中的右值引用使用的符号是&&。
int a = 1;
int& b = a; //b是a的别名，a是左值。
int& c = 1; //编译错误! 1是右值，不能够使用左值引用
int&& d = 1; //实质上就是将不具名(匿名)变量取了个别名
int&& e = a; //编译错误！a是左值，不能将一个左值复制给一个右值引用
class Base
{
public:
int base;
};
Base getBase()
{
return Base();
}
Base&& base = getBase(); //getBase()的返回值是右值（临时变量）getBase返回的右值本来在表达式语句结束后，其生命也就该终结了（因为是临时变量），而通过右值引用，该右值又重获新生，其生命期将与右值引用类型变量base的生命期一样，只要base还活着，该右值临时变量将会一直存活下去。实际上就是给那个临时变量取了个名字。
注意：这里base的类型是右值引用类型(int &&)，但是如果从左值和右值的角度区分它，它实际上是个左值。因为可以对它取地址，而且它还有名字，是一个已经命名的右值。
总结一下，其中T是一个具体类型：
1.左值引用， 使用 T&, 只能绑定左值
2.右值引用， 使用 T&&， 只能绑定右值
3.常量左值， 使用 const T&, 既可以绑定左值又可以绑定右值
4.已命名的右值引用，编译器会认为是个左值
5.编译器有返回值优化，但不要过于依赖
移动构造和移动赋值
#include
#include
#include
using namespace std;
class MyString
{
public:
static size_t CCtor; //统计调用拷贝构造函数的次数
static size_t MCtor; //统计调用移动构造函数的次数
static size_t CAsgn; //统计调用拷贝赋值函数的次数
static size_t MAsgn; //统计调用移动赋值函数的次数
public:
// 构造函数
MyString(const char* cstr=0)
{
if (cstr)
{
m_data = new char[strlen(cstr)+1];
strcpy(m_data, cstr);
}
else
{
m_data = new char[1];
*m_data = '\0';
}
}
// 拷贝构造函数
MyString(const MyString& str)
{
CCtor ++;
m_data = new char[ strlen(str.m_data) + 1 ];
strcpy(m_data, str.m_data);
}
// 移动构造函数
MyString(MyString&& str) noexcept
:m_data(str.m_data)
{
MCtor ++;
str.m_data = nullptr; //不再指向之前的资源了
}
// 拷贝赋值函数 =号重载
MyString& operator=(const MyString& str)
{
CAsgn ++;
if (this == &str) // 避免自我赋值!!
return *this;
delete[] m_data;
m_data = new char[ strlen(str.m_data) + 1 ];
strcpy(m_data, str.m_data);
return *this;
}
// 移动赋值函数 =号重载
MyString& operator=(MyString&& str) noexcept
{
MAsgn ++;
if (this == &str) // 避免自我赋值!!
return *this;
delete[] m_data;
m_data = str.m_data;
str.m_data = nullptr; //不再指向之前的资源了
return *this;
}
~MyString()
{
delete[] m_data;
}
char* get_c_str() const { return m_data; }
private:
char* m_data;
};
size_t MyString::CCtor = 0;
size_t MyString::MCtor = 0;
size_t MyString::CAsgn = 0;
size_t MyString::MAsgn = 0;
int main()
{
vector vecStr;
vecStr.reserve(1000); //先分配好1000个空间
for(int i=0;i<1000;i++)
{
vecStr.push_back(MyString("hello"));//调用的是移动构造函数
}
cout << "CCtor = " << MyString::CCtor << endl;
cout << "MCtor = " << MyString::MCtor << endl;
cout << "CAsgn = " << MyString::CAsgn << endl;
cout << "MAsgn = " << MyString::MAsgn << endl;
//vector vecStr2;
//vecStr2.reserve(1000); //先分配好1000个空间
//for(int i=0;i<1000;i++)
//{
// MyString tmp("hello");
// vecStr2.push_back(tmp); //调用的是拷贝构造函数
//}
//vector vecStr3;
//vecStr3.reserve(1000); //先分配好1000个空间
//for(int i=0;i<1000;i++)
//{
// MyString tmp("hello");
// vecStr3.push_back(std::move(tmp)); //调用的是移动构造函数
//}
}
/* 结果
CCtor = 0
MCtor = 1000
CAsgn = 0
MAsgn = 0
*/ 拷贝构造的参数是const MyString& str，是常量左值引用，而移动构造的参数是MyString&& str，是右值引用。
MyString("hello")是个临时对象，是个右值，优先进入移动构造函数而不是拷贝构造函数。而移动构造函数与拷贝构造不同，它并不是重新分配一块新的空间，将要拷贝的对象复制过来，而是"偷"了过来，将自己的指针指向别人的资源，然后将别人的指针修改为nullptr。
C++11提供了std::move()方法来将左值转换为右值。
MyString str1("hello"); //调用构造函数
MyString str2("world"); //调用构造函数
MyString str3(str1); //调用拷贝构造函数
MyString str4(std::move(str1)); // 调用移动构造函数，此时str1的内部指针已经失效了！不要使用
MyString str5;
str5 = str2; //调用拷贝赋值函数
MyString str6;
str6 = std::move(str2); // str2的内容也失效了，不要再使用
如果我们没有提供移动构造函数，只提供了拷贝构造函数，std::move()会失效但是不会发生错误，因为编译器找不到移动构造函数就去寻找拷贝构造函数，也这是拷贝构造函数的参数是const T&常量左值引用的原因！
C++11中的所有容器都实现了move语义，move只是转移了资源的控制权，本质上是将左值强制转化为右值使用，以用于移动拷贝或赋值，避免对含有资源的对象发生无谓的拷贝。move对于拥有如内存、文件句柄等资源的成员的对象有效，如果是一些基本类型，如int和char[10]数组等，如果使用move，仍会发生拷贝（因为没有对应的移动构造函数），所以说move对含有资源的对象说更有意义。
universal references(通用引用)
当右值引用和模板结合的时候，就复杂了。T&&并不一定表示右值引用，它可能是个左值引用又可能是个右值引用。例如：
template
void f( T&& param){
}
f(10); //10是右值
int x = 10; //
f(x); //x是左值 如果上面的函数模板表示的是右值引用的话，肯定是不能传递左值的，但是事实却是可以。这里的&&是一个未定义的引用类型，称为universal references，它必须被初始化，它是左值引用还是右值引用却决于它的初始化，如果它被一个左值初始化，它就是一个左值引用；如果被一个右值初始化，它就是一个右值引用。
注意：只有当发生自动类型推断时（如函数模板的类型自动推导，或auto关键字），&&才是一个universal references。
template
void f( T&& param); //这里T的类型需要推导，所以&&是一个 universal references
template
class Test {
Test(Test&& rhs); //Test是一个特定的类型，不需要类型推导，所以&&表示右值引用
};
void f(Test&& param); //右值引用
//复杂一点
template
void f(std::vector&& param); //在调用这个函数之前，这个vector中的推断类型
//已经确定了，所以调用f函数的时候没有类型推断了，所以是 右值引用
template
void f(const T&& param); //右值引用
// universal references仅仅发生在 T&& 下面，任何一点附加条件都会使之失效
所以最终还是要看T被推导成什么类型，如果T被推导成了string，那么T&&就是string&&，是个右值引用，如果T被推导为string&，就会发生类似string& &&的情况，对于这种情况，c++11增加了引用折叠的规则，总结如下:
1.所有的右值引用叠加到右值引用上仍然是一个右值引用。
2.所有的其他引用类型之间的叠加都将变成左值引用。
上面的T& &&其实就被折叠成了个string &，是一个左值引用。
#include
#include
#include
using namespace std;
template
void f(T&& param){
if (std::is_same::value)
std::cout << "string" << std::endl;
else if (std::is_same::value)
std::cout << "string&" << std::endl;
else if (std::is_same::value)
std::cout << "string&&" << std::endl;
else if (std::is_same::value)
std::cout << "int" << std::endl;
else if (std::is_same::value)
std::cout << "int&" << std::endl;
else if (std::is_same::value)
std::cout << "int&&" << std::endl;
else
std::cout << "unkown" << std::endl;
}
int main()
{
int x = 1;
f(1); // 参数是右值 T推导成了int, 所以是int&& param, 右值引用
f(x); // 参数是左值 T推导成了int&, 所以是int&&& param, 折叠成 int&,左值引用
int && a = 2;
f(a); //虽然a是右值引用，但它还是一个左值， T推导成了int&
string str = "hello";
f(str); //参数是左值 T推导成了string&
f(string("hello")); //参数是右值， T推导成了string，右值引用
f(std::move(str));//参数是右值， T推导成了string，右值引用
}
所以，归纳一下， 传递左值进去，就是左值引用，传递右值进去，就是右值引用。如它的名字，这种类型确实很"通用"，下面要讲的完美转发，就利用了这个特性
完美转发
所谓转发，就是通过一个函数将参数继续转交给另一个函数进行处理，原参数可能是右值，可能是左值，如果还能继续保持参数的原有特征，那么它就是完美的。
void process(int& i){
cout << "process(int&):" << i << endl;
}
void process(int&& i){
cout << "process(int&&):" << i << endl;
}
void myforward(int&& i){
cout << "myforward(int&&):" << i << endl;
process(i);
}
int main()
{
int a = 0;
process(a); //a被视为左值 process(int&):0
process(1); //1被视为右值 process(int&&):1
process(move(a)); //强制将a由左值改为右值 process(int&&):0
myforward(2); //右值经过forward函数转交给process函数，却称为了一个左值，
//原因是该右值有了名字 所以是 process(int&):2
myforward(move(a)); // 同上，在转发的时候右值变成了左值 process(int&):0
// forward(a) // 错误用法，右值引用不接受左值
}上面的例子就是不完美转发，而c++中提供了一个std::forward()模板函数解决这个问题。将上面的myforward()函数简单改写一下：
void myforward(int&& i)
{
cout << "myforward(int&&):" << i << endl;
process(std::forward(i));
}
myforward(2); // process(int&&):2 上面修改过后还是不完美转发，myforward()函数能够将右值转发过去，但是并不能够转发左值，解决办法就是借助universal references通用引用类型和std::forward()模板函数共同实现完美转发。例子如下：
#include
#include
#include
using namespace std;
void RunCode(int &&m) {
cout << "rvalue ref" << endl;
}
void RunCode(int &m) {
cout << "lvalue ref" << endl;
}
void RunCode(const int &&m) {
cout << "const rvalue ref" << endl;
}
void RunCode(const int &m) {
cout << "const lvalue ref" << endl;
}
// 这里利用了universal references，如果写T&,就不支持传入右值，而写T&&，既能支持左值，又能支持右值
template
void perfectForward(T && t) {
RunCode(forward (t));
}
template
void notPerfectForward(T && t) {
RunCode(t);
}
int main()
{
int a = 0;
int b = 0;
const int c = 0;
const int d = 0;
notPerfectForward(a); // lvalue ref
notPerfectForward(move(b)); // lvalue ref
notPerfectForward(c); // const lvalue ref
notPerfectForward(move(d)); // const lvalue ref
cout << endl;
perfectForward(a); // lvalue ref
perfectForward(move(b)); // rvalue ref
perfectForward(c); // const lvalue ref
perfectForward(move(d)); // const rvalue ref
}
参考
- 深入理解C++11:C++11新特性解析与应用
- 深入应用C++11:代码优化与工程级应用
- Effective Modern C++