第一节 · 划分领地 · 命名空间

C++11 引入的右值引用和移动语义是语言演进中最重要的特性之一，它们彻底改变了资源管理的方式。

---

左值与右值

int main()
{
    int x = 10;      // x 是左值，10 是右值
    int y = x + 1;   // x + 1 是右值
    
    // 左值：有名字，可以取地址
    int* p = &x;     // OK
    
    // 右值：临时的，不可取地址
    // int* p2 = &(x + 1);  // 错误
    
    return 0;
}

---

右值引用

int main()
{
    int x = 10;
    
    // 左值引用
    int& lref = x;
    // int& lref2 = 10;  // 错误：不能绑定到右值
    
    // const 左值引用可以绑定右值
    const int& clref = 10;  // OK
    
    // 右值引用
    int&& rref = 10;  // OK
    // int&& rref2 = x;  // 错误：不能绑定到左值
    
    // 右值引用本身是左值！
    int&& rref3 = move(x);  // 用 move 将左值转为右值
    
    return 0;
}

---

移动语义的动机

class String
{
    char* data;
    size_t length;
    
public:
    // 复制构造函数：深拷贝
    String(const String& other)
    {
        length = other.length;
        data = new char[length + 1];
        strcpy(data, other.data);
        cout << "Copy!" << endl;
    }
    
    // 问题：临时对象也要复制
    String createString()
    {
        String s("Hello");
        return s;  // 可能触发复制
    }
};

---

移动构造函数

class String
{
    char* data;
    size_t length;
    
public:
    String(const char* s)
    {
        length = strlen(s);
        data = new char[length + 1];
        strcpy(data, s);
    }
    
    // 复制构造
    String(const String& other)
    {
        length = other.length;
        data = new char[length + 1];
        strcpy(data, other.data);
        cout << "Copy" << endl;
    }
    
    // 移动构造
    String(String&& other) noexcept
        : data(other.data), length(other.length)
    {
        other.data = nullptr;
        other.length = 0;
        cout << "Move" << endl;
    }
    
    ~String()
    {
        delete[] data;
    }
};

int main()
{
    String s1("Hello");
    String s2 = s1;              // Copy
    String s3 = move(s1);        // Move
    String s4 = String("World"); // Move（编译器优化可能省略）
    
    return 0;
}

---

移动赋值运算符

class String
{
    char* data;
    size_t length;
    
public:
    // 移动赋值
    String& operator=(String&& other) noexcept
    {
        if (this != &other)
        {
            delete[] data;          // 释放旧资源
            
            data = other.data;      // 窃取资源
            length = other.length;
            
            other.data = nullptr;   // 置空源对象
            other.length = 0;
        }
        return *this;
    }
};

---

std::move

#include <utility>

int main()
{
    string s1 = "Hello, World!";
    
    // move 不移动任何东西，只是转换为右值引用
    string s2 = move(s1);  // s1 的内容移动到 s2
    
    // s1 现在处于"有效但未定义"的状态
    // 通常是空的，但不保证
    cout << "s1: " << s1 << endl;  // 可能是空
    cout << "s2: " << s2 << endl;  // Hello, World!
    
    return 0;
}

---

完美转发

// 不完美的转发
template<typename T>
void wrapper(T arg)
{
    process(arg);  // arg 总是左值
}

// 完美转发
template<typename T>
void perfectWrapper(T&& arg)
{
    process(forward<T>(arg));  // 保持原来的值类别
}

void process(int& x) { cout << "Lvalue" << endl; }
void process(int&& x) { cout << "Rvalue" << endl; }

int main()
{
    int x = 10;
    perfectWrapper(x);    // Lvalue
    perfectWrapper(10);   // Rvalue
    
    return 0;
}

---

引用折叠

// 规则：
// T& &   -> T&
// T& &&  -> T&
// T&& &  -> T&
// T&& && -> T&&

template<typename T>
void foo(T&& x)  // 万能引用
{
    // T = int&  时，T&& = int& && = int&
    // T = int   时，T&& = int&&
}

int main()
{
    int x = 10;
    foo(x);   // T = int&，x 是 int&
    foo(10);  // T = int，10 是 int&&
    
    return 0;
}

---

移动语义与容器

int main()
{
    vector<string> v;
    
    string s = "Hello";
    
    v.push_back(s);        // 复制
    v.push_back(move(s));  // 移动
    v.push_back("World");  // 移动（从临时对象）
    
    // emplace_back 直接构造
    v.emplace_back("!");   // 原地构造，最高效
    
    return 0;
}

---

移动-only 类型

class UniqueResource
{
    int* data;
    
public:
    UniqueResource() : data(new int(0)) {}
    ~UniqueResource() { delete data; }
    
    // 禁止复制
    UniqueResource(const UniqueResource&) = delete;
    UniqueResource& operator=(const UniqueResource&) = delete;
    
    // 允许移动
    UniqueResource(UniqueResource&& other) noexcept
        : data(other.data)
    {
        other.data = nullptr;
    }
    
    UniqueResource& operator=(UniqueResource&& other) noexcept
    {
        if (this != &other)
        {
            delete data;
            data = other.data;
            other.data = nullptr;
        }
        return *this;
    }
};

// unique_ptr 就是这样的类型

---

noexcept 的重要性

class Widget
{
public:
    // 标记 noexcept 很重要
    Widget(Widget&& other) noexcept;
    Widget& operator=(Widget&& other) noexcept;
};

// vector 扩容时：
// - 如果移动构造是 noexcept，使用移动
// - 否则使用复制（为了强异常安全）

---

习题

• 解释左值、右值、纯右值、将亡值的区别。

• 为一个资源管理类实现移动语义。

• 解释为什么移动后的对象应该处于有效状态。