C++11标准之右值引用（rvalue reference）

struct A {
A(int) {}
A(const A &) {}
};
A a = 42;

struct A {
A(int) {}
A(const A &) {}
};
A get() {return A(1);}
A a = get();

A get() {
A tmp(1); // #1
// do something
return tmp;
}
A a = get(); // #2

template <typename T>
void swap(T& a, T& b) {
T tmp(a);
a = b;
b = tmp;
}

struct A { A(){} };
A lvalue; // 非const左值对象
const A const_lvalue; // const左值对象
A rvalue() {return A();} // 返回一个非const右值对象
const A const_rvalue() {return A();} // 返回一个const右值对象// 规则一：非const左值引用只能绑定到非const左值
A &lvalue_reference1 = lvalue; // ok
A &lvalue_reference2 = const_lvalue; // error
A &lvalue_reference3 = rvalue(); // error
A &lvalue_reference4 = const_rvalue(); // error// 规则二：const左值引用可绑定到const左值、非const左值、const右值、非const右值
const A &const_lvalue_reference1 = lvalue; // ok
const A &const_lvalue_reference2 = const_lvalue; // ok
const A &const_lvalue_reference3 = rvalue(); // ok
const A &const_lvalue_reference4 = const_rvalue(); // ok// 规则三：非const右值引用只能绑定到非const右值
A &&rvalue_reference1 = lvalue; // error
A &&rvalue_reference2 = const_lvalue; // error
A &&rvalue_reference3 = rvalue(); // ok
A &&rvalue_reference4 = const_rvalue(); // error// 规则四：const右值引用可绑定到const右值和非const右值，不能绑定到左值
const A &&const_rvalue_reference1 = lvalue; // error
const A &&const_rvalue_reference2 = const_lvalue; // error
const A &&const_rvalue_reference3 = rvalue(); // ok
const A &&const_rvalue_reference4 = const_rvalue(); // ok// 规则五：函数类型例外
void fun() {}
typedef decltype(fun) FUN; // typedef void FUN();
FUN & lvalue_reference_to_fun = fun; // ok
const FUN & const_lvalue_reference_to_fun = fun; // ok
FUN && rvalue_reference_to_fun = fun; // ok
const FUN && const_rvalue_reference_to_fun = fun; // ok

[ Note: An expression is an xvalue if it is:
-- the result of calling a function, whether implicitly or explicitly, whose return type is an rvalue reference to object type,
-- a cast to an rvalue reference to object type,
-- a class member access expression designating a non-static data member of non-reference type in which the object expression is an xvalue, or
-- a .* pointer-to-member expression in which the first operand is an xvalue and the second operand is a pointer to data member.
In general, the effect of this rule is that named rvalue references are treated as lvalues and unnamed rvalue references to objects are treated as xvalues; rvalue references to functions are treated as lvalues whether named or not. --end note ]
[ Example:
struct A {
int m;
};
A&& operator+(A, A);
A&& f();
A a;
A&& ar = static_cast<A&&>(a);
The expressions f(), f().m, static_cast<A&&>(a), and a + a are xvalues. The expression ar is an lvalue.
--end example ]

A rvalue(){ return A(); }
A &&rvalue_reference() { return A(); }
fun(); // 返回的是不具名的右值引用，属于xvalue
A &&ra1 = rvalue(); // ra1是具名右值应用，属于左值
A &&ra2 = ra1; // error，ra1被当做左值对待，因此ra2不能绑定到ra1（不符合规则三）
A &la = ra1; // ok，非const左值引用可绑定到非const左值（符合规则一）

class A {
public:
A(const char *pstr = 0) { m_data = (pstr != 0 ? strcpy(new char[strlen(pstr) + 1], pstr) : 0); }
// copy constructor
A(const A &a) { m_data = (a.m_data != 0 ? strcpy(new char[strlen(a.m_data) + 1], a.m_data) : 0); }
// copy assigment
A &operator =(const A &a) {
if (this != &a) {
delete [] m_data;
m_data = (a.m_data != 0 ? strcpy(new char[strlen(a.m_data) + 1], a.m_data) : 0);
}
return *this;
}
// move constructor
A(A &&a) : m_data(a.m_data) { a.m_data = 0; }
// move assigment
A & operator = (A &&a) {
if (this != &a) {
m_data = a.m_data;
a.m_data = 0;
}
return *this;
}
~A() { delete [] m_data; }
private:
char * m_data;
};

template <typename T> // 如果T是class A
void swap(T& a, T& b) {
T tmp(a); // 根据右值引用的绑定规则三可知，这里不会调用move constructor，而会调用copy constructor
a = b; // 根据右值引用的绑定规则三可知，这里不会调用move assigment，而会调用copy assigment
b = tmp; // 根据右值引用的绑定规则三可知，这里不会调用move assigment，而会调用copy assigment
}

void swap(A &a, A &b) {
A tmp(std::move(a)); // std::move(a)为右值，这里会调用move constructor
a = std::move(b); // std::move(b)为右值，这里会调用move assigment
b = std::move(tmp); // std::move(tmp)为右值，这里会调用move assigment
}

template <class _Tp>
inline typename remove_reference<_Tp>::type&& move(_Tp&& __t) {
typedef typename remove_reference<_Tp>::type _Up;
return static_cast<_Up&&>(__t);
}

template <class _Tp> struct remove_reference {typedef _Tp type;};
template <class _Tp> struct remove_reference<_Tp&> {typedef _Tp type;};
template <class _Tp> struct remove_reference<_Tp&&> {typedef _Tp type;};

template <class _Tp> void f(_Tp &&) { /* do something */ }
template <class _Tp> void g(const _Tp &&) { /* do something */ }
int x = 123;
f(x); // ok，f()模板函数形参为非const非volatile右值引用类型，实参x为int类型左值，使用int&来做参数推导，因此调用f<int &>(int &)
f(456); // ok，实参为右值，调用f<int>(int &&)
g(x); // error，g()函数模板参数为const右值引用类型，会调用g<int>(const int &&)，通过右值引用规则四可知道，const右值引用不能绑定到左值，因此会导致编译错误

#include <iostream>
#include <cstring>#define PRINT(msg) do { std::cout << msg << std::endl; } while(0)template <class _Tp> struct remove_reference {typedef _Tp type;};
template <class _Tp> struct remove_reference<_Tp&> {typedef _Tp type;};
template <class _Tp> struct remove_reference<_Tp&&> {typedef _Tp type;};template <class _Tp>
inline typename remove_reference<_Tp>::type&& move(_Tp&& __t) {
typedef typename remove_reference<_Tp>::type _Up;
return static_cast<_Up&&>(__t);
}class A {
public:
A(const char *pstr) {
PRINT("constructor");
m_data = (pstr != 0 ? strcpy(new char[strlen(pstr) + 1], pstr) : 0);
}
A(const A &a) {
PRINT("copy constructor");
m_data = (a.m_data != 0 ? strcpy(new char[strlen(a.m_data) + 1], a.m_data) : 0);
}
A &operator =(const A &a) {
PRINT("copy assigment");
if (this != &a) {
delete [] m_data;
m_data = (a.m_data != 0 ? strcpy(new char[strlen(a.m_data) + 1], a.m_data) : 0);
}
return *this;
}
A(A &&a) : m_data(a.m_data) {
PRINT("move constructor");
a.m_data = 0;
}
A & operator = (A &&a) {
PRINT("move assigment");
if (this != &a) {
m_data = a.m_data;
a.m_data = 0;
}
return *this;
}
~A() { PRINT("destructor"); delete [] m_data; }
private:
char * m_data;
};void swap(A &a, A &b) {
A tmp(move(a));
a = move(b);
b = move(tmp);
}int main(int argc, char **argv, char **env) {
A a("123"), b("456");
swap(a, b);
return 0;
}

constructor
constructor
move constructor
move assigment
move assigment
destructor
destructor
destructor