C++深入右值引用之移动语义与完美转发(最新推荐)

int* p = new int(0);
int b = 1;
const int c = b;
*p = 10;            // *p 是左值
string s("hello");
s[0] = 'x';         // s[0] 是左值
10;                 // 右值
x + y;              // 右值
string("hello");    // 右值
// cout << &10;     // 错误：右值不能取地址

int& r1 = b;          // 左值引用绑定左值
int&& rr1 = 10;       // 右值引用绑定右值
double&& rr2 = x + y;
string&& rr3 = string("hello");

const int& cr = 10;           // OK
int&& rr4 = move(b);          // OK，move后的b仍可使用但资源已被取走

int&& rr = 10;
cout << &rr << endl;   // 可以取地址，rr是左值
int& lr = rr;          // OK，rr作为左值可以绑定左值引用
// int&& rr2 = rr;     // 错误，rr是左值，不能直接绑定右值引用
int&& rr2 = move(rr);  // OK

string addStrings(string num1, string num2) {
    string str;
    // ... 构建str ...
    return str;  // str是局部对象，函数结束就销毁，不能传引用返回
}

namespace demo {
class string {
public:
    string(const char* str = "")
        : _size(strlen(str)), _capacity(_size)
    {
        _str = new char[_capacity + 1];
        strcpy(_str, str);
    }
    // 拷贝构造
    string(const string& s) {
        // 深拷贝...
    }
    // 移动构造
    string(string&& s) {
        swap(s);   // 直接把s的资源换到自己身上
    }
    // 拷贝赋值
    string& operator=(const string& s) {
        // 深拷贝...
    }
    // 移动赋值
    string& operator=(string&& s) {
        swap(s);
        return *this;
    }
    void swap(string& s) {
        std::swap(_str, s._str);
        std::swap(_size, s._size);
        std::swap(_capacity, s._capacity);
    }
    ~string() { delete[] _str; }
private:
    char* _str = nullptr;
    size_t _size = 0;
    size_t _capacity = 0;
};
}

demo::string s1("hello");
demo::string s2 = s1;              // 拷贝构造
demo::string s3 = demo::string("world");  // 移动构造（临时对象）
demo::string s4 = move(s1);        // 移动构造（显式move）

void push_back(const T& x);   // 左值版本，内部拷贝
void push_back(T&& x);        // 右值版本，内部移动

list<demo::string> lt;
demo::string s1("hello");
lt.push_back(s1);                          // 拷贝
lt.push_back(move(s1));                    // 移动
lt.push_back("world");                     // 移动（临时string）
lt.push_back(demo::string("world"));       // 移动

template<class T>
void relay(T&& t) {
    func(t);  // t是左值，永远调用func的左值版本，即使传进来的是右值
}

template<class T>
void relay(T&& t) {
    func(forward<T>(t));
}

typedef int&  lref;
typedef int&& rref;
lref&  r1 = n;  // int&  &  → int&
lref&& r2 = n;  // int&  && → int&
rref&  r3 = n;  // int&& &  → int&
rref&& r4 = 1;  // int&& && → int&&

class Person {
public:
    Person(const Person&) = default;   // 显式要拷贝
    Person(Person&&) = default;        // 显式要移动
};