std::string str = "hello";
std::string str2 = std::move(str);  // 把str伪装成右值，触发移动构造函数
// 现在str变成了空字符串（但处于有效状态）

class MyString {
    // 移动构造函数：参数是右值引用
    MyString(MyString&& other) noexcept {
        data = other.data;   // 偷指针
        size = other.size;
        other.data = nullptr; // 原对象置空
        other.size = 0;
    }
    // 移动赋值运算符
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] data;         // 释放自己的旧资源
            data = other.data;     // 偷资源
            size = other.size;
            other.data = nullptr;  // 原对象置空
            other.size = 0;
        }
        return *this;
    }
};

std::vector<std::pair<int, std::string>> v;
v.push_back(std::make_pair(1, "hello"));
// 流程：先构造一个临时pair -> 拷贝/移动到vector -> 销毁临时pair

v.emplace_back(1, "hello");  // 直接在vector末尾构造pair

// 不好：先构造临时 string，再拷贝/移动到 vector
std::vector<std::string> words;
words.push_back(std::string("apple"));

// 好：直接在 vector 内部构造，省掉临时对象
words.emplace_back("apple");

#include <iostream>
#include <vector>
#include <cstring>
#include <utility>  // for std::move

class MyString {
private:
    char* data;      // 指向动态分配的字符数组
    size_t size;     // 字符串长度（不含结尾'\0'）
public:
    // 构造函数：从C风格字符串创建
    MyString(const char* str) {
        size = strlen(str);
        data = new char[size + 1];
        strcpy(data, str);
        std::cout << "构造: " << data << std::endl;
    }

    // 拷贝构造函数：深拷贝
    MyString(const MyString& other) {
        size = other.size;
        data = new char[size + 1];
        strcpy(data, other.data);
        std::cout << "拷贝构造: " << data << std::endl;
    }

    // 移动构造函数：偷走 other 的资源
    MyString(MyString&& other) noexcept {
        data = other.data;          // 直接偷指针
        size = other.size;
        other.data = nullptr;      // 原对象置空
        other.size = 0;
        std::cout << "移动构造: " << (data ? data : "(空)") << std::endl;
    }

    // 拷贝赋值运算符
    MyString& operator=(const MyString& other) {
        if (this != &other) {
            delete[] data;              // 释放自己原有的内存
            size = other.size;
            data = new char[size + 1];
            strcpy(data, other.data);
            std::cout << "拷贝赋值: " << data << std::endl;
        }
        return *this;
    }

    // 移动赋值运算符
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] data;              // 释放自己的旧资源
            data = other.data;          // 偷资源
            size = other.size;
            other.data = nullptr;       // 原对象置空
            other.size = 0;
            std::cout << "移动赋值: " << (data ? data : "(空)") << std::endl;
        }
        return *this;
    }

    // 析构函数
    ~MyString() {
        delete[] data;
    }

    void print() const {
        if (data) std::cout << data;
        else std::cout << "(空)";
    }
};

int main() {
    std::vector<MyString> v;  // 存储 MyString 的 vector

    std::cout << "--- 使用 push_back 传入临时对象 ---" << std::endl;
    v.push_back(MyString("Hello"));
    // 输出：构造: Hello → 移动构造: Hello → 析构临时对象
    // 注意：这里调用了移动构造（因为 MyString("Hello") 是右值）

    std::cout << "\n--- 使用 emplace_back 直接在容器内构造 ---" << std::endl;
    v.emplace_back("World");
    // 输出：构造: World  （只有一次构造，没有临时对象）

    std::cout << "\n--- 使用 push_back 并显式 std::move 左值 ---" << std::endl;
    MyString str("MoveMe");
    v.push_back(std::move(str));  // 把左值转成右值，触发移动构造
    std::cout << "移动后 str 是: ";
    str.print();
    std::cout << std::endl;
    // 输出：构造: MoveMe → 移动构造: MoveMe → 移动后 str 是: (空)

    std::cout << "\n--- 验证 vector 中的内容 ---" << std::endl;
    for (const auto& s : v) {
        s.print();
        std::cout << " ";
    }
    std::cout << std::endl;

    return 0;
}