Merge branch 'Awesome-Embedded-Learning-Studio:main' into main

Author: owollz4

code/examples/vol1/c_float_representation.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <string.h>
+
+/* 浮点数为什么是近似值？把 0.1f 的 32 个二进制位摊开看就明白了。 */
+int main(void) {
+    /* 1) float 只有 32 位：1 符号 + 8 指数 + 23 尾数 */
+    float f = 0.1f;
+    unsigned int bits;
+    memcpy(&bits, &f, sizeof(bits));
+
+    printf("0.1f 存进 float 的 32 个二进制位 (符号 | 指数 | 尾数):\n  ");
+    for (int i = 31; i >= 0; i--) {
+        printf("%d", (bits >> i) & 1);
+        if (i == 31 || i == 23)
+            printf(" ");
+    }
+    printf("\n\n");
+
+    /* 尾数 1001100110011... 是无限循环，23 位放不下只能截断，所以不是 0.1 */
+    printf("用不同精度打印它，都不是 0.1：\n");
+    printf("  9 位精度 : %.9f\n", f);
+    printf("  20 位精度: %.20f\n\n", f);
+
+    /* 2) 经典的 0.1 + 0.2 != 0.3 在 double 下才看得见 */
+    double a = 0.1, b = 0.2, c = 0.3;
+    printf("double: 0.1 + 0.2 == 0.3 ? %s\n", (a + b == c) ? "yes" : "no");
+    printf("  a + b = %.20f\n", a + b);
+    printf("  c     = %.20f\n", c);
+
+    return 0;
+}

code/examples/vol1/c_float_representation_en.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <string.h>
+
+/* Why are floating-point numbers approximations? Spread out the 32 bits of 0.1f and it becomes
+ * clear. */
+int main(void) {
+    /* 1) float has only 32 bits: 1 sign + 8 exponent + 23 mantissa */
+    float f = 0.1f;
+    unsigned int bits;
+    memcpy(&bits, &f, sizeof(bits));
+
+    printf("32 bits of 0.1f in a float (sign | exponent | mantissa):\n  ");
+    for (int i = 31; i >= 0; i--) {
+        printf("%d", (bits >> i) & 1);
+        if (i == 31 || i == 23)
+            printf(" ");
+    }
+    printf("\n\n");
+
+    /* The mantissa 1001100110011... repeats forever; 23 bits can't hold it, so it gets truncated.
+     */
+    printf("Printed at different precisions — never exactly 0.1:\n");
+    printf("  9 digits : %.9f\n", f);
+    printf("  20 digits: %.20f\n\n", f);
+
+    /* 2) The classic 0.1 + 0.2 != 0.3 only shows up under double */
+    double a = 0.1, b = 0.2, c = 0.3;
+    printf("double: 0.1 + 0.2 == 0.3 ? %s\n", (a + b == c) ? "yes" : "no");
+    printf("  a + b = %.20f\n", a + b);
+    printf("  c     = %.20f\n", c);
+
+    return 0;
+}

code/examples/vol2/01_rvalue_reference.cpp

@@ -1,5 +1,6 @@
 // 01_rvalue_reference.cpp
 // 右值引用与值类别：构造、拷贝、移动、析构全过程追踪
+// Standard: C++17
 
 #include <iostream>
 #include <string>
@@ -12,17 +13,35 @@ class Tracker {
     explicit Tracker(std::string name) : name_(std::move(name)) {
         std::cout << "  [" << name_ << "] 构造\n";
     }
+
     Tracker(const Tracker& other) : name_(other.name_ + "_copy") {
         std::cout << "  [" << name_ << "] 拷贝构造\n";
     }
+
     Tracker(Tracker&& other) noexcept : name_(std::move(other.name_)) {
         other.name_ = "(moved-from)";
         std::cout << "  [" << name_ << "] 移动构造\n";
     }
+
     ~Tracker() { std::cout << "  [" << name_ << "] 析构\n"; }
+
+    Tracker& operator=(const Tracker& other) {
+        name_ = other.name_ + "_copy";
+        std::cout << "  [" << name_ << "] 拷贝赋值\n";
+        return *this;
+    }
+
+    Tracker& operator=(Tracker&& other) noexcept {
+        name_ = std::move(other.name_);
+        other.name_ = "(moved-from)";
+        std::cout << "  [" << name_ << "] 移动赋值\n";
+        return *this;
+    }
+
     const std::string& name() const { return name_; }
 };
 
+/// @brief 返回临时对象（prvalue）
 Tracker make_tracker(std::string name) {
     return Tracker(std::move(name));
 }
@@ -34,16 +53,23 @@ int main() {
 
     std::cout << "=== 2. 拷贝构造 ===\n";
     Tracker b = a;
-    std::cout << "  a.name = " << a.name() << "\n  b.name = " << b.name() << "\n\n";
+    std::cout << "  a.name = " << a.name() << "\n";
+    std::cout << "  b.name = " << b.name() << "\n\n";
 
     std::cout << "=== 3. 移动构造（显式 std::move）===\n";
     Tracker c = std::move(a);
-    std::cout << "  a.name = " << a.name() << "\n  c.name = " << c.name() << "\n\n";
+    std::cout << "  a.name = " << a.name() << "\n";
+    std::cout << "  c.name = " << c.name() << "\n\n";
 
     std::cout << "=== 4. 返回临时对象 ===\n";
     Tracker d = make_tracker("D");
     std::cout << "  d.name = " << d.name() << "\n\n";
 
-    std::cout << "=== 5. 程序结束，析构顺序 ===\n";
+    std::cout << "=== 5. 移动赋值 ===\n";
+    d = std::move(b);
+    std::cout << "  b.name = " << b.name() << "\n";
+    std::cout << "  d.name = " << d.name() << "\n\n";
+
+    std::cout << "=== 6. 程序结束，析构顺序 ===\n";
     return 0;
 }

code/examples/vol2/02_move_semantics.cpp

@@ -1,5 +1,6 @@
 // 02_move_semantics.cpp
-// 移动构造与移动赋值：Buffer 资源所有权转移与 vector 操作对比
+// 移动构造与移动赋值：Buffer 资源转移全过程追踪
+// Standard: C++17
 
 #include <cstring>
 #include <iostream>
@@ -17,24 +18,40 @@ class Buffer {
         : data_(new char[capacity]), size_(0), capacity_(capacity) {
         std::cout << "  [Buffer] 分配 " << capacity << " 字节\n";
     }
+
     ~Buffer() {
         if (data_) {
             std::cout << "  [Buffer] 释放 " << capacity_ << " 字节\n";
             delete[] data_;
         }
     }
+
     Buffer(const Buffer& other)
         : data_(new char[other.capacity_]), size_(other.size_), capacity_(other.capacity_) {
         std::memcpy(data_, other.data_, size_);
         std::cout << "  [Buffer] 拷贝构造 " << capacity_ << " 字节\n";
     }
+
     Buffer(Buffer&& other) noexcept
         : data_(other.data_), size_(other.size_), capacity_(other.capacity_) {
         other.data_ = nullptr;
         other.size_ = 0;
         other.capacity_ = 0;
         std::cout << "  [Buffer] 移动构造（指针转移）\n";
     }
+
+    Buffer& operator=(const Buffer& other) {
+        if (this != &other) {
+            delete[] data_;
+            data_ = new char[other.capacity_];
+            size_ = other.size_;
+            capacity_ = other.capacity_;
+            std::memcpy(data_, other.data_, size_);
+            std::cout << "  [Buffer] 拷贝赋值 " << capacity_ << " 字节\n";
+        }
+        return *this;
+    }
+
     Buffer& operator=(Buffer&& other) noexcept {
         if (this != &other) {
             delete[] data_;
@@ -48,17 +65,20 @@ class Buffer {
         }
         return *this;
     }
+
     void append(const char* str, std::size_t len) {
         if (size_ + len <= capacity_) {
             std::memcpy(data_ + size_, str, len);
             size_ += len;
         }
     }
+
     std::size_t size() const { return size_; }
+    std::size_t capacity() const { return capacity_; }
 };
 
 int main() {
-    std::cout << "=== 1. 创建缓冲区 ===\n";
+    std::cout << "=== 1. 创建两个缓冲区 ===\n";
     Buffer a(1024);
     a.append("Hello", 5);
     Buffer b(2048);
@@ -71,17 +91,25 @@ int main() {
 
     std::cout << "=== 3. 移动构造 ===\n";
     Buffer d = std::move(b);
-    std::cout << "  d.size() = " << d.size() << "\n\n";
+    std::cout << "  d.size() = " << d.size() << "\n";
+    std::cout << "  b.capacity() = " << b.capacity() << "\n\n";
 
-    std::cout << "=== 4. vector 中的移动 ===\n";
+    std::cout << "=== 4. 移动赋值 ===\n";
+    a = std::move(d);
+    std::cout << "  a.size() = " << a.size() << "\n";
+    std::cout << "  d.capacity() = " << d.capacity() << "\n\n";
+
+    std::cout << "=== 5. vector 中的移动 ===\n";
     std::vector<Buffer> buffers;
     buffers.reserve(4);
     std::cout << "  push_back 左值:\n";
-    buffers.push_back(c);
+    buffers.push_back(c); // 拷贝
     std::cout << "  push_back std::move:\n";
-    buffers.push_back(std::move(c));
+    buffers.push_back(std::move(c)); // 移动
     std::cout << "  emplace_back 原位构造:\n";
-    buffers.emplace_back(512);
+    buffers.emplace_back(512); // 直接在 vector 中构造
+    std::cout << '\n';
 
+    std::cout << "=== 6. 程序结束 ===\n";
     return 0;
 }

code/examples/vol2/noexcept_vector_realloc.cpp

@@ -0,0 +1,65 @@
+// noexcept_vector_realloc.cpp -- noexcept 移动 vs 非 noexcept 移动 在 vector 扩容时的差异
+// Standard: C++17
+
+#include <iostream>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+// 用模板参数 NoexceptMove 切换移动构造是否标 noexcept，其余代码完全相同
+template <bool NoexceptMove> class TrackedBuffer {
+    char* data_;
+    std::size_t capacity_;
+    std::string tag_;
+
+  public:
+    explicit TrackedBuffer(std::size_t cap, std::string tag)
+        : data_(new char[cap]), capacity_(cap), tag_(std::move(tag)) {}
+
+    ~TrackedBuffer() { delete[] data_; }
+
+    TrackedBuffer(const TrackedBuffer& other)
+        : data_(new char[other.capacity_]), capacity_(other.capacity_), tag_(other.tag_) {
+        std::cout << "  [" << tag_ << "] 拷贝构造\n";
+    }
+
+    // 唯一的区别：noexcept 标记
+    TrackedBuffer(TrackedBuffer&& other) noexcept(NoexceptMove)
+        : data_(other.data_), capacity_(other.capacity_), tag_(std::move(other.tag_)) {
+        other.data_ = nullptr;
+        other.capacity_ = 0;
+        std::cout << "  [" << tag_ << "] 移动构造\n";
+    }
+
+    TrackedBuffer& operator=(const TrackedBuffer&) = delete;
+    TrackedBuffer& operator=(TrackedBuffer&&) = delete;
+};
+
+int main() {
+    using NB = TrackedBuffer<true>;  // 移动构造标了 noexcept
+    using TB = TrackedBuffer<false>; // 移动构造没标 noexcept
+
+    static_assert(std::is_nothrow_move_constructible_v<NB>, "NB 的移动构造是 noexcept");
+    static_assert(!std::is_nothrow_move_constructible_v<TB>, "TB 的移动构造不是 noexcept");
+
+    std::cout << "=== noexcept 移动 + vector 扩容 ===\n";
+    {
+        std::vector<NB> v;
+        v.reserve(1);                     // 先预留 1 个槽位
+        v.emplace_back(64, "Noexcept版"); // 占住唯一的槽位
+        std::cout << "--- 触发扩容 ---\n";
+        v.emplace_back(64, "Noexcept版"); // 超出容量，必须扩容搬运
+    }
+
+    std::cout << "\n=== 非 noexcept 移动 + vector 扩容 ===\n";
+    {
+        std::vector<TB> v;
+        v.reserve(1);
+        v.emplace_back(64, "Throwing版");
+        std::cout << "--- 触发扩容 ---\n";
+        v.emplace_back(64, "Throwing版"); // 扩容时 vector 不敢用移动，退回拷贝
+    }
+
+    return 0;
+}

code/examples/vol2/rule_of_five_fallback.cpp

@@ -0,0 +1,36 @@
+// rule_of_five_fallback.cpp -- 只有析构函数时，std::move 退化为拷贝构造
+// Standard: C++17
+
+#include <iostream>
+#include <type_traits>
+#include <utility>
+
+// 只定义了析构函数，没有声明任何拷贝/移动操作
+class OnlyDestructor {
+    char* data_;
+
+  public:
+    explicit OnlyDestructor(std::size_t n) : data_(new char[n]) {}
+
+    ~OnlyDestructor() { delete[] data_; }
+    // 注意：这里既没有声明移动构造，也没有声明拷贝构造
+};
+
+// 编译期验证：它「能移动构造」，但不是因为真有移动构造函数
+static_assert(!std::is_trivially_move_constructible_v<OnlyDestructor>,
+              "没有真正的（平凡的）移动构造函数");
+static_assert(std::is_move_constructible_v<OnlyDestructor>,
+              "但 is_move_constructible 为 true —— 编译器退回到拷贝构造来满足");
+
+int main() {
+    std::cout
+        << "is_trivially_move_constructible_v: "
+        << std::is_trivially_move_constructible_v<OnlyDestructor> << "  (没有真正的移动构造)\n";
+    std::cout << "is_move_constructible_v:           "
+              << std::is_move_constructible_v<OnlyDestructor> << "  (但能用拷贝构造蒙混过关)\n";
+
+    // 真要执行 OnlyDestructor b = std::move(a)，隐式拷贝构造做浅拷贝，
+    // a 和 b 的 data_ 指向同一块内存，两者析构时 double free。
+    // 这里不真的跑（会崩），编译期 static_assert 已经给出结论。
+    return 0;
+}