移动构造函数与移动赋值

class Buffer {
public:
    Buffer(Buffer&& other) noexcept;              // 移动构造
    Buffer& operator=(Buffer&& other) noexcept;   // 移动赋值
};

#include <iostream>
#include <cstring>
#include <algorithm>
#include <chrono>

class StringBuffer {
public:
    // 普通构造
    explicit StringBuffer(const char* str = "")
        : size_(std::strlen(str)), data_(new char[size_ + 1]) {
        std::strcpy(data_, str);
        std::cout << "[构造] \"" << data_ << "\"" << std::endl;
    }

    // 拷贝构造
    StringBuffer(const StringBuffer& other)
        : size_(other.size_), data_(new char[size_ + 1]) {
        std::strcpy(data_, other.data_);
        std::cout << "[拷贝构造] \"" << data_ << "\"" << std::endl;
    }

    // 移动构造
    StringBuffer(StringBuffer&& other) noexcept
        : size_(other.size_), data_(other.data_) {
        // 窃取资源后置空源对象
        other.size_ = 0;
        other.data_ = nullptr;
        std::cout << "[移动构造] 资源已转移" << std::endl;
    }

    // 拷贝赋值
    StringBuffer& operator=(const StringBuffer& other) {
        std::cout << "[拷贝赋值]" << std::endl;
        if (this != &other) {
            StringBuffer temp(other);
            std::swap(size_, temp.size_);
            std::swap(data_, temp.data_);
        }
        return *this;
    }

    // 移动赋值
    StringBuffer& operator=(StringBuffer&& other) noexcept {
        std::cout << "[移动赋值]" << std::endl;
        if (this != &other) {
            delete[] data_;            // 释放自己的旧资源
            data_ = other.data_;       // 窃取
            size_ = other.size_;
            other.data_ = nullptr;     // 置空源对象
            other.size_ = 0;
        }
        return *this;
    }

    ~StringBuffer() {
        std::cout << "[析构] size=" << size_
                  << (data_ ? (" \"" + std::string(data_) + "\"") : " (空)")
                  << std::endl;
        delete[] data_;
    }

    size_t size() const { return size_; }
    const char* c_str() const { return data_ ? data_ : ""; }

private:
    size_t size_;
    char* data_;
};

// 工厂函数：返回临时对象
StringBuffer make_buffer() {
    return StringBuffer("临时生成的字符串内容");
}

int main() {
    std::cout << "===== 移动构造：接收临时对象 =====" << std::endl;
    StringBuffer buf = make_buffer();  // 移动构造（或 RVO 优化）
    std::cout << "缓冲区内容: " << buf.c_str() << std::endl;

    std::cout << "\n===== 移动赋值 =====" << std::endl;
    StringBuffer buf2("原始内容");
    buf2 = StringBuffer("新内容");  // 移动赋值

    std::cout << "\n===== 显式移动 =====" << std::endl;
    StringBuffer buf3("可移动的数据");
    std::cout << "移动前 buf3: " << buf3.c_str() << std::endl;
    StringBuffer buf4 = std::move(buf3);  // 显式移动
    std::cout << "移动后 buf3: \"" << buf3.c_str() << "\" (空)" << std::endl;
    std::cout << "移动后 buf4: \"" << buf4.c_str() << "\"" << std::endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <chrono>

class HeavyData {
public:
    std::string label;
    std::vector<int> numbers;  // 大块数据

    HeavyData(std::string lbl, size_t count)
        : label(std::move(lbl)), numbers(count) {
        for (size_t i = 0; i < count; ++i) numbers[i] = static_cast<int>(i);
    }

    // 拷贝（昂贵）
    HeavyData(const HeavyData& other)
        : label(other.label), numbers(other.numbers) {
        // 逐元素拷贝 numbers
    }

    // 移动（廉价）
    HeavyData(HeavyData&& other) noexcept
        : label(std::move(other.label)),
          numbers(std::move(other.numbers)) {
        // 只交换了几个指针
    }
};

int main() {
    const size_t DATA_SIZE = 1'000'000;  // 100 万个 int

    std::cout << "===== 拷贝 vs 移动性能对比 =====" << std::endl;

    // ---- 拷贝 ----
    HeavyData original("原始数据", DATA_SIZE);

    auto t1 = std::chrono::steady_clock::now();
    HeavyData copied = original;  // 拷贝构造：深拷贝 100 万个 int
    auto t2 = std::chrono::steady_clock::now();
    auto copy_time = std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1);

    // ---- 移动 ----
    auto t3 = std::chrono::steady_clock::now();
    HeavyData moved = std::move(original);  // 移动构造：O(1) 指针交换
    auto t4 = std::chrono::steady_clock::now();
    auto move_time = std::chrono::duration_cast<std::chrono::microseconds>(t4 - t3);

    std::cout << "数据大小: " << DATA_SIZE << " 个 int" << std::endl;
    std::cout << "拷贝耗时: " << copy_time.count() << " ms" << std::endl;
    std::cout << "移动耗时: " << move_time.count() << " us" << std::endl;

    std::cout << "\n===== vector 扩容中的移动 =====" << std::endl;
    std::vector<HeavyData> vec;
    vec.reserve(1);

    auto t5 = std::chrono::steady_clock::now();
    vec.emplace_back("数据1", 100000);
    vec.emplace_back("数据2", 100000);  // 扩容时移动首个元素
    vec.emplace_back("数据3", 100000);  // 扩容时移动前两个元素
    auto t6 = std::chrono::steady_clock::now();
    auto vec_time = std::chrono::duration_cast<std::chrono::milliseconds>(t6 - t5);

    std::cout << "3 次 push_back（含扩容）: " << vec_time.count() << " ms" << std::endl;
    std::cout << "感谢 noexcept 移动，扩容使用移动而非拷贝！" << std::endl;

    return 0;
}