feat(vol2): 优化 ch00/05 与 ch01 智能指针全章(de-AI+清死链+实测验证)

ch00/05 移动语义实战:
- 修正 benchmark 数据硬伤(原文「285ms/3倍」与实测矛盾)→ GCC16 实测重写
- 补全 noexcept 验证代码(原缺 ThrowingType,代码与输出对不上)
- 清死链 code/volumn_codes/vol2/ch00-move-semantics(空目录)
- 新增 2 个 OnlineCompilerDemo(push_back_emplace、noexcept_sort_vs_realloc)

ch01 智能指针 6 篇 CN:
- 人称统一(笔者/咱们/您)、删「## 小结」换承接、清 AI 味词、工具链 GCC16
- 修实测硬伤:
  · raii-deep-dive:exit 验证缺 main(给了输出却链接不过)
  · unique-ptr:sizeof 代码缺 StatefulDeleter 但输出里有;5 处死链 + PIMPL 死链
  · weak-ptr:lock() 实测慢 ~32 倍(原文写 10-15 倍,把直接访问耗时写高了)
  · custom-deleter:11 处死链 + 末尾整段「## 验证代码」死链 + 535-536 重复行
  · scope-guard:验证段死链

新增 code/examples/vol2: noexcept_sort_vs_realloc.cpp、move_benchmark.cpp、push_back_emplace.cpp(均 GCC16 编译验证)

EN 同步 ch00/05 + ch01/01-04

Author: Charliechen114514

code/examples/vol2/move_benchmark.cpp

@@ -0,0 +1,94 @@
+// move_benchmark.cpp -- 拷贝 vs 移动性能对比（分离构造开销）
+// Standard: C++17
+// 对应文档：vol2-modern-features/ch00-move-semantics/05-move-in-practice.md
+//
+// 关键设计：把"构造"这一固定开销单独测出来作为 baseline，再用
+// (构造+拷贝) - 构造 和 (构造+移动) - 构造 得到纯粹的拷贝/移动耗时，
+// 避免构造开销稀释掉移动操作本身"接近零"的事实。
+//
+// 注意：绝对耗时是机器相关的，但"纯移动 ≈ 0、纯拷贝 >> 0"的结论稳定。
+#include <chrono>
+#include <iostream>
+#include <numeric>
+#include <string>
+#include <vector>
+
+class BigData {
+    std::vector<double> payload_;
+
+  public:
+    explicit BigData(std::size_t n) : payload_(n) {
+        std::iota(payload_.begin(), payload_.end(), 0.0);
+    }
+
+    BigData(const BigData& other) : payload_(other.payload_) {}
+    BigData(BigData&& other) noexcept = default;
+    BigData& operator=(const BigData&) = default;
+    BigData& operator=(BigData&&) noexcept = default;
+};
+
+/// @brief 测量函数执行时间的辅助模板
+template <typename Func> double measure_ms(Func&& func, int iterations) {
+    auto start = std::chrono::high_resolution_clock::now();
+    for (int i = 0; i < iterations; ++i) {
+        func();
+    }
+    auto end = std::chrono::high_resolution_clock::now();
+    return std::chrono::duration<double, std::milli>(end - start).count();
+}
+
+int main() {
+    constexpr std::size_t kDataSize = 1000000; // 100 万个 double，约 8MB
+    constexpr int kIterations = 100;
+
+    std::cout << "数据大小: " << kDataSize * sizeof(double) / 1024 << " KB\n";
+    std::cout << "迭代次数: " << kIterations << "\n\n";
+
+    // 测试 0：仅构造（baseline）
+    auto construct_time = measure_ms(
+        [&]() {
+            BigData source(kDataSize);
+            (void)source;
+        },
+        kIterations);
+
+    std::cout << "仅构造（baseline）: " << construct_time << " ms\n";
+
+    // 测试 1：构造 + 拷贝
+    auto copy_time = measure_ms(
+        [&]() {
+            BigData source(kDataSize);
+            BigData copy = source; // 拷贝构造
+            (void)copy;
+        },
+        kIterations);
+
+    std::cout << "构造 + 拷贝:        " << copy_time << " ms\n";
+
+    // 测试 2：构造 + 移动
+    auto move_time = measure_ms(
+        [&]() {
+            BigData source(kDataSize);
+            BigData moved = std::move(source); // 移动构造
+            (void)moved;
+        },
+        kIterations);
+
+    std::cout << "构造 + 移动:        " << move_time << " ms\n\n";
+
+    // 分离出纯粹的拷贝/移动耗时
+    double actual_copy = copy_time - construct_time;
+    double actual_move = move_time - construct_time;
+
+    std::cout << "=== 分离后的实际耗时 ===\n";
+    std::cout << "纯拷贝: " << actual_copy << " ms\n";
+    std::cout << "纯移动: " << actual_move << " ms\n";
+
+    if (actual_move > 0.01) {
+        std::cout << "加速比: " << actual_copy / actual_move << "x\n";
+    } else {
+        std::cout << "移动耗时在测量噪声范围内（接近零）\n";
+    }
+
+    return 0;
+}

code/examples/vol2/noexcept_sort_vs_realloc.cpp

@@ -0,0 +1,142 @@
+// noexcept_sort_vs_realloc.cpp -- 验证 noexcept 对 std::sort 和 vector 扩容的影响
+// Standard: C++17
+// 对应文档：vol2-modern-features/ch00-move-semantics/05-move-in-practice.md
+//
+// 核心结论：
+//   - std::sort 只用移动，不区分移动操作是否 noexcept（两种类型都是 拷贝=0）
+//   - vector 扩容通过 move_if_noexcept 选择策略：noexcept 类型用移动，
+//     非 noexcept 类型退回拷贝（强异常安全）
+#include <algorithm>
+#include <iostream>
+#include <string>
+#include <vector>
+
+// 移动操作带 noexcept 的类型
+struct NoexceptType {
+    std::string payload;
+    int value;
+
+    static int copy_count;
+    static int move_count;
+
+    NoexceptType(int v) : payload("data"), value(v) {}
+    NoexceptType(const NoexceptType& o) : payload(o.payload + "_c"), value(o.value) {
+        ++copy_count;
+    }
+    NoexceptType(NoexceptType&& o) noexcept : payload(std::move(o.payload)), value(o.value) {
+        o.payload = "(moved)";
+        ++move_count;
+    }
+    NoexceptType& operator=(NoexceptType&& o) noexcept {
+        payload = std::move(o.payload);
+        value = o.value;
+        o.payload = "(moved)";
+        ++move_count;
+        return *this;
+    }
+    NoexceptType& operator=(const NoexceptType& o) {
+        payload = o.payload + "_c";
+        value = o.value;
+        ++copy_count;
+        return *this;
+    }
+    bool operator<(const NoexceptType& rhs) const { return value < rhs.value; }
+    static void reset() {
+        copy_count = 0;
+        move_count = 0;
+    }
+};
+
+// ThrowingType 与 NoexceptType 完全相同，唯一区别是移动操作没有 noexcept
+struct ThrowingType {
+    std::string payload;
+    int value;
+
+    static int copy_count;
+    static int move_count;
+
+    ThrowingType(int v) : payload("data"), value(v) {}
+    ThrowingType(const ThrowingType& o) : payload(o.payload + "_c"), value(o.value) {
+        ++copy_count;
+    }
+    ThrowingType(ThrowingType&& o) // 注意：没有 noexcept
+        : payload(std::move(o.payload)), value(o.value) {
+        o.payload = "(moved)";
+        ++move_count;
+    }
+    ThrowingType& operator=(ThrowingType&& o) // 注意：没有 noexcept
+    {
+        payload = std::move(o.payload);
+        value = o.value;
+        o.payload = "(moved)";
+        ++move_count;
+        return *this;
+    }
+    ThrowingType& operator=(const ThrowingType& o) {
+        payload = o.payload + "_c";
+        value = o.value;
+        ++copy_count;
+        return *this;
+    }
+    bool operator<(const ThrowingType& rhs) const { return value < rhs.value; }
+    static void reset() {
+        copy_count = 0;
+        move_count = 0;
+    }
+};
+
+int NoexceptType::copy_count = 0;
+int NoexceptType::move_count = 0;
+int ThrowingType::copy_count = 0;
+int ThrowingType::move_count = 0;
+
+int main() {
+    const int kCount = 5000;
+
+    // Test 1: std::sort（noexcept 类型）
+    {
+        std::vector<NoexceptType> vec;
+        vec.reserve(kCount);
+        for (int i = 0; i < kCount; ++i)
+            vec.emplace_back(kCount - i);
+        NoexceptType::reset();
+        std::sort(vec.begin(), vec.end());
+        std::cout << "noexcept sort:  拷贝=" << NoexceptType::copy_count
+                  << " 移动=" << NoexceptType::move_count << "\n";
+    }
+
+    // Test 2: std::sort（非 noexcept 类型）
+    {
+        std::vector<ThrowingType> vec;
+        vec.reserve(kCount);
+        for (int i = 0; i < kCount; ++i)
+            vec.emplace_back(kCount - i);
+        ThrowingType::reset();
+        std::sort(vec.begin(), vec.end());
+        std::cout << "非noexcept sort: 拷贝=" << ThrowingType::copy_count
+                  << " 移动=" << ThrowingType::move_count << "\n";
+    }
+
+    std::cout << "\n";
+
+    // Test 3: vector 扩容（noexcept 类型，无 reserve）
+    {
+        NoexceptType::reset();
+        std::vector<NoexceptType> vec;
+        for (int i = 0; i < 200; ++i)
+            vec.emplace_back(i);
+        std::cout << "noexcept 扩容:  拷贝=" << NoexceptType::copy_count
+                  << " 移动=" << NoexceptType::move_count << "\n";
+    }
+
+    // Test 4: vector 扩容（非 noexcept 类型，无 reserve）
+    // ThrowingType 的扩容会退回拷贝，因为 move_if_noexcept 不选中它的移动
+    {
+        ThrowingType::reset();
+        std::vector<ThrowingType> vec;
+        for (int i = 0; i < 200; ++i)
+            vec.emplace_back(i);
+        std::cout << "非noexcept扩容: 拷贝=" << ThrowingType::copy_count
+                  << " 移动=" << ThrowingType::move_count << "\n";
+    }
+}

code/examples/vol2/push_back_emplace.cpp

@@ -0,0 +1,54 @@
+// push_back_emplace.cpp -- push_back(拷贝/移动) vs emplace_back(原位构造) 对比
+// Standard: C++17
+// 对应文档：vol2-modern-features/ch00-move-semantics/05-move-in-practice.md
+//
+// 核心结论：
+//   - push_back(lvalue) 触发拷贝构造
+//   - push_back(std::move(rvalue)) 触发移动构造
+//   - emplace_back(构造参数) 连移动都省了，直接原位构造
+#include <iostream>
+#include <string>
+#include <vector>
+
+class Heavy {
+    std::string name_;
+    std::vector<int> data_;
+
+  public:
+    explicit Heavy(std::string name, std::size_t n) : name_(std::move(name)), data_(n, 42) {
+        std::cout << "  [" << name_ << "] 构造，数据量: " << data_.size() << "\n";
+    }
+
+    Heavy(const Heavy& other) : name_(other.name_ + "_copy"), data_(other.data_) {
+        std::cout << "  [" << name_ << "] 拷贝构造\n";
+    }
+
+    Heavy(Heavy&& other) noexcept : name_(std::move(other.name_)), data_(std::move(other.data_)) {
+        other.name_ = "(moved-from)";
+        std::cout << "  [" << name_ << "] 移动构造\n";
+    }
+
+    ~Heavy() { std::cout << "  [" << name_ << "] 析构，数据量: " << data_.size() << "\n"; }
+
+    const std::string& name() const { return name_; }
+    std::size_t data_size() const { return data_.size(); }
+};
+
+int main() {
+    std::vector<Heavy> items;
+    items.reserve(4);
+
+    std::cout << "=== push_back 左值（拷贝）===\n";
+    Heavy h1("Alpha", 10000);
+    items.push_back(h1);
+
+    std::cout << "\n=== push_back 右值（移动）===\n";
+    Heavy h2("Beta", 10000);
+    items.push_back(std::move(h2));
+
+    std::cout << "\n=== emplace_back 原位构造 ===\n";
+    items.emplace_back("Gamma", 10000);
+
+    std::cout << "\n=== 程序结束 ===\n";
+    return 0;
+}