std::move 深度解析：从原理到实践

class DataPayload {
    std::string content_;
public:
    // ⚠️ 移动构造函数未标记 noexcept：潜在性能陷阱
    DataPayload(DataPayload&& other) 
        : content_(std::move(other.content_)) {}
    
    DataPayload(const DataPayload& other) 
        : content_(other.content_) {}
    
    explicit DataPayload(const char* data) : content_(data) {}
};

std::vector<DataPayload> generateRecords() {
    std::vector<DataPayload> records;
    // ... 填充大量数据 ...
    return records;  // 预期：高效移动返回
}

// <utility> 中的标准实现（简化）
#include <type_traits>

template<typename T>
constexpr typename std::remove_reference<T>::type&&
move(T&& arg) noexcept {
    return static_cast<typename std::remove_reference<T>::type&&>(arg);
}

template<typename T>
void wrapper(T&& param) {
    // param 的类型可能是 T& 或 T&&，但表达式 param 本身是 lvalue！
    consume(std::move(param));  // 需要显式转换才能触发移动
}

// 依赖声明
#include <utility>      // std::move, std::exchange
#include <algorithm>    // std::copy
#include <new>          // std::bad_alloc

class BufferManager {
private:
    int* buffer_;
    size_t capacity_;

public:
    // 1. 构造函数
    explicit BufferManager(size_t cap) 
        : buffer_(new int[cap]), capacity_(cap) {}

    // 2. 析构函数（释放资源）
    ~BufferManager() {
        delete[] buffer_;
    }

    // 3. 拷贝构造函数（深拷贝）
    BufferManager(const BufferManager& other)
        : buffer_(new int[other.capacity_]), 
          capacity_(other.capacity_) {
        std::copy(other.buffer_, other.buffer_ + capacity_, buffer_);
    }

    // 4. 拷贝赋值运算符（深拷贝 + 异常安全）
    BufferManager& operator=(const BufferManager& other) {
        if (this != &other) {
            // 先分配新资源（强异常保证）
            int* new_buf = new int[other.capacity_];
            std::copy(other.buffer_, other.buffer_ + other.capacity_, new_buf);
            
            // 成功后再释放旧资源
            delete[] buffer_;
            buffer_ = new_buf;
            capacity_ = other.capacity_;
        }
        return *this;
    }

    // 5. 移动构造函数（资源转移 + noexcept）
    BufferManager(BufferManager&& other) noexcept
        : buffer_(std::exchange(other.buffer_, nullptr)),
          capacity_(std::exchange(other.capacity_, 0)) {}

    // 6. 移动赋值运算符（资源转移 + noexcept + 自赋值检查）
    BufferManager& operator=(BufferManager&& other) noexcept {
        if (this != &other) {
            delete[] buffer_;  // 清理自身资源
            buffer_ = std::exchange(other.buffer_, nullptr);
            capacity_ = std::exchange(other.capacity_, 0);
        }
        return *this;
    }
};

// ✅ 正确：允许编译器执行返回值优化
DataPayload buildResult() {
    DataPayload temp;
    // ... 填充数据 ...
    return temp;  // 编译器可能：①直接构造到调用者空间（NRVO）②自动移动（C++17+）
}

// ❌ 不推荐：显式移动反而降低代码清晰度
DataPayload buildResult() {
    DataPayload temp;
    return std::move(temp);  // 阻止 NRVO，但 C++17+ 仍会自动移动
}

// C++17+ 语义等价（在无法执行拷贝省略时）：
return obj;                    // 编译器自动视为右值
return std::move(obj);         // 显式转换为右值

void process() {
    const DataPayload payload = fetchData();
    sink(std::move(payload));  // ❌ 静默退化为拷贝！
}

std::string label = "config";
std::string cloned = std::move(label);
std::cout << label.size();  // ⚠️ 逻辑错误：label 的值处于未指定状态

std::string label = "config";
std::string cloned = std::move(label);
// label 不再使用，或显式重置
label = "new_value";  // ✅ 安全
label.clear();        // ✅ 安全

std::vector<std::string> source = loadStrings();
std::vector<std::string> target;

// ❌ 低效：每次迭代执行拷贝
for (const auto& item : source) {
    target.push_back(item);
}

// ✅ 高效：显式移动（注意：source 内容将被清空）
for (auto& item : source) {
    target.push_back(std::move(item));
}

// ✅ 更优：整体移动向量（若不再需要 source）
std::vector<std::string> target = std::move(source);

// 传统方式：函数调用开销
for (size_t i = 0; i < count; ++i) {
    new (&new_storage[i]) T(std::move(old_storage[i]));  // 移动构造
    old_storage[i].~T();                                  // 显式析构
}

// 新特性（概念示意，接口可能调整）
if constexpr (std::is_trivially_relocatable_v<T>) {
    // 允许使用内存拷贝批量迁移
    std::memcpy(new_storage, old_storage, count * sizeof(T));
    // 旧内存整体失效，无需逐个析构
}

// 场景 1：确定要移动 → 用 std::move
void handle(DataPayload&& temp) {
    storage_.insert(std::move(temp));  // temp 不再使用
}

// 场景 2：转发参数 → 用 std::forward
template<typename T>
void wrapper(T&& arg) {
    target_.process(std::forward<T>(arg));  // 保持 arg 的原始值类别
}

// 反模式 1：阻止编译器优化决策
ReturnType func() {
    ReturnType result;
    return std::move(result);  // ❌ 降低代码清晰度，可能阻碍优化
}

// 反模式 2：从 const 移动
void process(const std::string& src) {
    auto cloned = std::move(src);  // ❌ 实际执行拷贝，性能回退
}

// 反模式 3：移动后依赖具体值
std::string data = "value";
auto transferred = std::move(data);
if (!data.empty()) { ... }  // ❌ 逻辑错误：data 的值不可预测

// 反模式 4：遗漏 noexcept
class Widget {
    Widget(Widget&&) { ... }  // ❌ 未标记 noexcept，容器扩容时退化为拷贝
};

# GCC/Clang 编译选项建议
g++ -std=c++20 -O3 -Wall -Wextra -Wmove -Wpedantic -DNDEBUG your_code.cpp

// move_test.cpp
#include <iostream>
#include <utility>
#include <vector>

class TestObj {
public:
    TestObj() { std::cout << "construct\n"; }
    ~TestObj() { std::cout << "destruct\n"; }
    
    TestObj(const TestObj&) { std::cout << "copy\n"; }
    TestObj(TestObj&&) noexcept { std::cout << "move\n"; }
};

int main() {
    std::vector<TestObj> vec;
    vec.emplace_back();  // construct
    vec.reserve(100);    // 触发扩容：应输出 "move" 而非 "copy"
}

# 编译运行
g++ -std=c++20 -O2 move_test.cpp -o move_test && ./move_test
# 预期输出：construct → move（若无 noexcept 则输出 copy）