• 类似概念：C++ 中的悬空指针/引用检查。
• 困惑点：C++ 默认信任程序员能控住引用生命周期。Rust 要求在结构体或函数签名中显式用 'a 标注引用之间的绑定关系。
• 核心机理：生命周期标注不会改变变量的实际存活时间，它只是通知编译器（借用检查器）多个引用之间的生存期约束，防止“容器还在，但里面的引用指向的对象已被销毁”的情况。

• 类似概念：C++11 的结构化绑定（Structured Binding）与解引用。
• 困惑点：在 match 或 if let 中，普通变量绑定会默认移动（Move）所有权。如果你只想借用部分字段，必须使用 ref。
• 核心机理：let ref x = y; 等价于 let x = &y;。在 C++ 中，你在左侧写 & 表示引用；而在 Rust 的模式匹配中，左侧写 & 表示解引用匹配，写 ref 才表示创建引用。

在 match 或 if let 中匹配一个结构体或枚举时，如果你不小心，也会把里面的字段给 Move 掉。

struct User { name: String, age: u32 }
let user = User { name: String::from("Alice"), age: 30 };

match user {
    User { name, age } => { ... } // 💥 极其隐蔽的陷阱！
}

• 为什么困惑：这里的 name 变量会把 user.name 的所有权 Move 出来！这导致匹配完成后，整个 user 变量直接报废（变成了部分初始化状态）。
• 正确的做法：如果你只想看一眼，必须显式匹配为引用。在老版本 Rust 中需要写 User { ref name, age }，现代 Rust 允许你在匹配目标前加引用：

  match &user { // 👈 对整个对象取引用
      User { name, age } => { ... } // 此时 name 自动推导为 &String
  }

• 类似概念：C++ 的虚函数表（vtable）和基类指针 Base*。
• 困惑点：Rust 的 Trait（类似虚基类）不能直接作为变量类型或返回值，必须写成 &dyn Trait 或 Box<dyn Trait>。
• 核心机理：C++ 的多态对象在胖指针内部包含 vptr。而 Rust 的 dyn Trait 是胖指针（Fat Pointer），包含两个部分：指向数据的指针和指向虚函数表的指针。因此，dyn Trait 是一个不确定大小的类型（Unsized），必须隐藏在指针后面。

• 类似概念：C++ 的移动构造函数（Move Constructor）与 std::move。
• 困惑点：Rust 中所有赋值和传参默认都是 Move，且 Move 之后原变量立刻失效（编译期拦截），这不需要写类似 std::move 的代码。
• 核心机理：Rust 的 Move 仅仅是极为高效的内存浅拷贝（memcpy）。如果一个类型实现了 Copy trait（如 i32），赋值才会变成复制。C++ 移动后留下一个“有效但未定义”的空壳，而 Rust 移动后该内存直接不可访问。

• 类似概念：C++ 闭包的捕获列表 [&]、[=]、[values = std::move(x)]。
• 困惑点：Rust 闭包的捕获方式是由闭包体内的使用方式自动推导的，但有时必须显式加上 move 关键字。
• 核心机理：如果不加 move，闭包会默认尝试以最小权限（不可变引用 -> 可变引用 -> 移动）来捕获外部变量。加上 move 关键字则强制将所有捕获变量的所有权转移进闭包，这在多线程（如 thread::spawn）传输闭包时是强制要求的。

let mut text = String::from("Rust");

// 情况 A：不加 move
let print_text = || println!("{}", text); 
// 👆 此时闭包内部捕获的是 text 的【引用】（&String）

// 情况 B：加了 move
let print_text_move = move || println!("{}", text); 
// 👆 此时 text 的【所有权】被强行移动到了闭包内部

• 类似概念：C++ 的 operator->() 和 operator*() 运算符重载。
• 困惑点：为什么 String 类型的变量可以直接传给接收 &str 的函数？为什么 &Box<T> 可以直接当 &T 用？
• 核心机理：Rust 编译器在发现类型不匹配时，如果该类型实现了 Deref trait，会自动插入解引用操作（例如把 &String 隐式转换为 &str）。这种“悄悄发生”的转换经常让习惯了 C++ 严格类型匹配的开发者感到困惑。

let s: String = String::from("hello");
// String 没有 .len() 方法，.len() 是定义在 str 切片上的。
// 但由于 Deref 存在，Rust 会自动把 &String 变成 &str
println!("{}", s.len()); 

let words = vec![String::from("hello"), String::from("world")];

// 困惑点 A：for-in 循环默认会“吃掉”集合
for w in words { ... } 
// 👆 这里的 words 发生了 Move！循环结束后，words 变量彻底死掉，无法再使用。

// 困惑点 B：.iter() 和 .into_iter() 截然不同
for w in words.iter() { ... }       // ✅ w 的类型是 &String（借用，words 还能用）
for w in words.into_iter() { ... }  // 💥 w 的类型是 String（Move，words 完蛋）

let s1 = String::from("hello ");
let s2 = String::from("world");

let s3 = s1 + &s2; // ✅ 成功编译
// let s4 = &s1 + &s2; // ❌ 编译报错！
// let s5 = s1 + s2;   // ❌ 编译报错！