🦀 Rust 所有权与借用

1. 为什么需要所有权

内存管理是系统编程的核心难题。在 Rust 之前，业界主要采用两种方案，但都有明显的问题。

┌─────────────────────────────────────────────────────────────────────┐ │ 内存管理的三条路 │ ├──────────────┬──────────────────┬────────────────────────────────────┤ │ 手动管理 │ 垃圾回收(GC) │ 所有权系统 │ │ C/C++ │ Java/Go/JS │ Rust │ ├──────────────┼──────────────────┼────────────────────────────────────┤ │ ✅ 零开销 │ ✅ 安全 │ ✅ 零开销 │ │ ✅ 可预测 │ ✅ 开发效率高 │ ✅ 安全(编译期保证) │ │ ❌ 悬垂指针 │ ❌ Stop-the-world│ ✅ 可预测 │ │ ❌ 二次释放 │ ❌ 运行时开销 │ ❌ 学习曲线陡 │ │ ❌ 内存泄漏 │ ❌ 延迟不确定 │ │ │ ❌ Use-after-free│❌ 内存占用高 │ │ └──────────────┴──────────────────┴────────────────────────────────────┘

C/C++ 的困境：自由代价高昂

C++

// 经典的 use-after-free
int* p = (int*)malloc(sizeof(int));
*p = 42;
free(p);
// ... 几百行之后 ...
int x = *p;  // 💥 未定义行为，可能崩，可能不崩，最恐怖的是"好像能跑"

C++ 程序员花大量时间调试内存问题。Valgrind、AddressSanitizer、智能指针——这些都是对手动管理缺陷的补救措施，而非根本解决方案。

Go/Java 的困境：安全的代价是运行时

Go

func process() *Data {
    d := &Data{...}
    // Go 的 GC 会在某个不确定的时刻回收
    // 但 GC 需要运行时，占用额外 5-20% CPU
    // 且 STW(Stop-The-World) 导致延迟抖动
    return d
}

Go 的 GC 虽然低延迟，但仍然：

需要 ~5% 的 CPU 开销
内存占用比实际使用多 2-4 倍（预分配 + GC 压力）
无法用于实时系统（延迟抖动不可控）
嵌入式中几乎不可用

Rust 的第三条路：编译期所有权检查

Rust 的洞察是：内存安全的规则可以在编译期静态检查，而不需要运行时 GC。代价是程序员必须在代码中显式表达"谁拥有这块内存"——但这恰恰使得程序员的意图更清晰。

💡 核心思想：所有权不是限制，是契约。你告诉编译器"这块内存归谁管"，编译器帮你保证不会出问题。如果契约不合理，编译器在编译期就拒绝你，而不是在运行时崩溃。

2. 所有权规则

Rust 的所有权系统建立在三条简单规则之上：

══════════════════════════════════════════════ 所有权三规则 ══════════════════════════════════════════════ 规则1 每个值有且只有一个 owner（所有者）规则2 同一时刻，值只能被一个变量拥有规则3 owner 离开作用域时，值被自动释放（drop） ══════════════════════════════════════════════

规则1：每个值只有一个 owner

Rust

let s = String::from("hello");
// s 是 "hello" 这个 String 值的 owner
// 只有一个 owner，就是 s

栈 (Stack) 堆 (Heap) ┌─────────────┐ ┌─────────────────┐ │ s │ │ h e l l o │ │ ┌─────────┐ │ ┌───────▶ │ │ │ │ ptr │─┼────┘ │ │ │ │ len: 5 │ │ └─────────────────┘ │ │ cap: 5 │ │ ▲ │ └─────────┘ │ │ └─────────────┘ 只有一个 owner 指向这块堆内存

规则2：赋值是转移（Move），不是复制

✅ 可以编译

let x: i32 = 42;
let y = x;  // i32 实现了 Copy
// x 和 y 都有效，值被复制

❌ 编译失败

let s1 = String::from("hello");
let s2 = s1;  // String 没有实现 Copy
// s1 被移动到 s2，s1 不再有效
println!("{}", s1); // ❌ value borrowed
// here after move

规则3：离开作用域自动释放

Rust

fn main() {
    {
        let s = String::from("hello");
        // s 在这个作用域内有效
    } // ← s 离开作用域，自动调用 drop(s)
      //   堆上的 "hello" 被释放，无需手动 free

    // println!("{}", s);  // ❌ s 不存在了
}

作用域开始作用域结束 │ │ ▼ ▼ ┌─────────────────┐ ┌─────────────────┐ │ let s = ... │ │ } │ │ │ ───▶ │ drop(s) 自动调用 │ │ s ──▶ "hello" │ │ 堆内存释放 │ └─────────────────┘ └─────────────────┘ 无需手动 free，编译器在作用域结尾插入 drop 调用

与 C++ 的对比

特性	C++ RAII	Rust 所有权
自动析构	析构函数	Drop trait
拷贝语义	默认深拷贝	默认 move
悬垂引用	可能发生	编译期阻止
双重释放	可能发生	不可能(move 后原变量无效)
智能指针	unique_ptr/shared_ptr	Box/Arc/Rc

3. Move语义详解

Move 语义是所有权系统的核心机制。理解 move，就理解了 Rust 为什么不需要 GC。

String 的 Move

String 由栈上的元数据（指针、长度、容量）和堆上的实际数据组成。赋值时，栈上的元数据被复制，但堆数据不会——否则两个 owner 都会尝试释放同一块内存。

let s1 = String::from("hello"); 栈堆 ┌──────────┐ ┌─────────────┐ │ s1 │ │ h e l l o │ │ ptr ────┼───────────────▶│ │ │ len: 5 │ └─────────────┘ │ cap: 5 │ └──────────┘ let s2 = s1; // move！不是 clone！栈堆 ┌──────────┐ ┌─────────────┐ │ s1 │ ╳ 已失效 │ h e l l o │ │ (invalid)│ │ │ └──────────┘ └─────────────┘ ┌──────────┐ ▲ │ s2 │ │ │ ptr ────┼─────────────────────┘ │ len: 5 │ │ cap: 5 │ └──────────┘ s1 失效 → 不会二次释放堆内存 s2 接管 → 只有 s2 会在离开作用域时释放

🚫 编译器说不行：let s2 = s1; 之后使用 s1 会得到 error[E0382]: use of moved value: s1。这不是建议，是硬性编译错误。

栈数据的 Copy 语义

如果类型的全部数据都在栈上，且复制成本低，Rust 允许它实现 Copy trait。Copy 类型赋值时自动复制，原变量仍然有效。

Rust

let x: i32 = 42;
let y = x;  // i32 是 Copy 类型，值被复制
println!("x = {}, y = {}", x, y);  // ✅ 两个都有效

let a = (1, 2.0, true);  // 元组内都是 Copy 类型
let b = a;               // 整个元组也是 Copy
println!("{:?}", a);     // ✅ 仍然有效

哪些类型实现了 Copy？

Copy 类型 ✅	非 Copy 类型 ❌
所有整数类型 (i8..i128, u8..u128)	String
浮点数 (f32, f64)	Vec<T>
布尔值 (bool)	Box<T>
字符 (char)	HashMap / BTreeMap
元组（仅含 Copy 类型）	元组（含非 Copy 类型）
数组 [T; N]（T: Copy）	数组（T 非 Copy）
共享引用 &T	可变引用 &mut T

⚠️ 注意：&mut T 不是 Copy！同一时刻只能有一个可变引用，如果 Copy 就违反了借用规则。&T 是 Copy，因为多个不可变引用是允许的。

clone()：显式深拷贝

Rust

let s1 = String::from("hello");
let s2 = s1.clone();  // 显式深拷贝，堆数据也被复制
println!("s1 = {}, s2 = {}", s1, s2);  // ✅ 两个都有效

let s2 = s1.clone(); 栈堆 ┌──────────┐ ┌─────────────┐ │ s1 │ │ h e l l o │ │ ptr ────┼───────────────▶│ │ │ len: 5 │ └─────────────┘ │ cap: 5 │ └──────────┘ ┌─────────────┐ ┌──────────┐ │ h e l l o │ │ s2 │ │ (独立的副本) │ │ ptr ────┼───────────────▶│ │ │ len: 5 │ └─────────────┘ │ cap: 5 │ └──────────┘ 两份独立的堆数据，各自释放各自的

函数传参的 Move

把值传给函数，和赋值一样——要么 move，要么 copy。

✅ Copy 类型传参

fn print_i32(x: i32) {
    println!("{}", x);
}

let n = 42;
print_i32(n);
println!("{}", n); // ✅ n 仍然有效

❌ 非 Copy 类型传参

fn print_string(s: String) {
    println!("{}", s);
} // s 被 drop

let s = String::from("hello");
print_string(s);
println!("{}", s); // ❌ s 已被 move
// error: value borrowed after move

解决办法：传引用（下一节详述），或者传所有权再返回。

Rust

// 方案1：传引用
fn print_string(s: &String) {
    println!("{}", s);
}
let s = String::from("hello");
print_string(&s);
println!("{}", s);  // ✅ s 仍然有效

// 方案2：返回所有权
fn consume_and_return(s: String) -> String {
    println!("{}", s);
    s  // 所有权返回给调用者
}
let s = String::from("hello");
let s = consume_and_return(s);  // 重新绑定
println!("{}", s);  // ✅

4. 借用与引用

如果每次传参都要 move 再返回，代码会非常啰嗦。Rust 的解决方案是借用——创建一个指向值的引用，但不获取所有权。

不可变引用 &T

Rust

fn calculate_length(s: &String) -> usize {
    s.len()
} // s 离开作用域，但因为它没有所有权，不会 drop 原值

let s1 = String::from("hello");
let len = calculate_length(&s1);
// s1 仍然有效！我们只是"借"给函数看了看
println!("'{}' 的长度是 {}", s1, len);

不可变引用 &T 栈堆 ┌──────────┐ ┌──────────┐ ┌─────────────┐ │ s1 │ │ &s1 │ │ h e l l o │ │ ptr ────┼──┐ │ ─────────┼──┐ │ │ │ len: 5 │ │ │ (引用) │ │ └─────────────┘ │ cap: 5 │ │ │ │ │ ▲ └──────────┘ │ └──────────┘ │ │ │ └─────────┤ └─────────────────────────┘ &s1 只能读，不能改，也不能释放 s1 仍然是唯一的所有者

可变引用 &mut T

Rust

fn add_world(s: &mut String) {
    s.push_str(", world");
}

let mut s = String::from("hello");
add_world(&mut s);
println!("{}", s);  // "hello, world"

借用规则：Rust 最重要的安全保证

══════════════════════════════════════════════════ 借用规则（The Alias + Mutability Rule） ══════════════════════════════════════════════════ 允许：多个 &T（多个读者）允许：一个 &mut T（唯一写者）禁止：&T 和 &mut T 同时存在（读写冲突）禁止：多个 &mut T 同时存在（写写冲突）简记：要么多个读，要么一个写，绝不同时 ══════════════════════════════════════════════════

✅ 多个不可变引用

let s = String::from("hello");

let r1 = &s;   // 第1个 &T
let r2 = &s;   // 第2个 &T
let r3 = &s;   // 第3个 &T

println!("{} {} {}", r1, r2, r3);
// ✅ 多个读没问题

❌ 可变 + 不可变引用

let mut s = String::from("hello");

let r1 = &s;      // 不可变引用
let r2 = &mut s;   // ❌ 可变引用

println!("{} {}", r1, r2);
// error: cannot borrow `s` as mutable
// because it is also borrowed as immutable

❌ 多个可变引用

let mut s = String::from("hello");

let r1 = &mut s;
let r2 = &mut s;  // ❌

// error: cannot borrow `s` as mutable
// more than once at a time

✅ 非重叠的作用域

let mut s = String::from("hello");

{
    let r1 = &mut s;
    r1.push_str("1");
} // r1 生命周期结束

let r2 = &mut s;  // ✅ r1 已失效
r2.push_str("2");

NLL（Non-Lexical Lifetimes）

Rust 2018 引入了 NLL，引用的生命周期在最后一次使用时结束，而不是在作用域结束时。这让代码更自然：

Rust

let mut s = String::from("hello");

let r1 = &s;
println!("{}", r1);   // r1 最后一次使用

// r1 的生命周期在此结束（NLL），即使作用域未结束
let r2 = &mut s;      // ✅ 在 NLL 下可以编译
println!("{}", r2);

💡 NLL 的意义：引用的生命周期不是看花括号，而是看实际使用位置。编译器会分析引用的"活跃范围"，只在真正冲突时报错。这让大量之前无法编译的代码变得合法。

与 Go 的对比

特性	Go	Rust
共享可变状态	允许（需加锁保证安全）	编译期禁止
数据竞争	运行时检测 (race detector)	编译期消除
指针安全	GC 保证不悬垂	借用规则保证不悬垂
并发安全	Channel / Mutex	Send + Sync + 借用规则

5. 悬垂引用

悬垂引用（Dangling Reference）是指引用指向了已被释放的内存。在 C/C++ 中这是最常见的安全漏洞来源之一。Rust 的借用规则在编译期就杜绝了它。

编译器如何阻止悬垂引用

✅ 返回拥有所有权的值

fn produce_string() -> String {
    let s = String::from("hello");
    s  // 所有权转移到调用者
}
let s = produce_string();
println!("{}", s); // ✅

❌ 返回局部变量的引用

fn dangling() -> &String {
    let s = String::from("hello");
    &s  // ❌ 返回局部变量的引用
}   // s 被 drop，引用悬垂

// error: missing lifetime specifier
// this function's return type contains
// a borrowed value, but there is no value
// for it to be borrowed from

悬垂引用为什么危险函数执行时：函数返回后： ┌─────────────────────┐ ┌─────────────────────┐ │ 栈帧 │ │ 栈帧已被回收 │ │ ┌──────────┐ │ │ ┌──────────┐ │ │ │ s │ │ │ │ ？？？？？ │ │ │ │ ptr ──▶ "hello" │ │ │ 指向哪里？ │ │ │ └──────────┘ │ │ └──────────┘ │ │ &s ──▶ s │ │ &s ──▶ 💀 │ └─────────────────────┘ └─────────────────────┘ C/C++：可能不报错，运行时数据损坏 Rust：编译器直接拒绝，不可能运行

与 C++ 的对比

C++

// C++ 中这段代码能编译，但运行时未定义行为
std::string& dangling() {
    std::string s = "hello";
    return s;  // 返回局部变量的引用
}  // s 被销毁，引用悬垂
// 调用者得到一个悬垂引用——可能"正常工作"，也可能崩溃

🚫 编译器说不行：Rust 编译器看到 -> &String 但函数体内没有可以从参数借用的值，直接报错 missing lifetime specifier。你必须要么返回拥有所有权的 String，要么从参数中借用——编译器会验证借用的合法性。

6. 生命周期标注

当函数接受引用参数并返回引用时，编译器需要知道返回的引用和哪个输入引用关联。生命周期标注就是告诉编译器这个关联关系。

为什么需要生命周期标注

Rust

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() { x } else { y }
}
// ❌ 编译器不知道返回值引用的是 x 还是 y
// 如果 x/y 的实际生命周期不同，可能产生悬垂引用

问题场景调用：longest(&s1, &s2) 时间 ─────────────────────────────────────▶ s1 ████████████████████████████ s2 ████████████ 返回？ ?????????????????????███ 如果返回的是 x 的引用，但 x 比 y 活得久 → 没问题如果返回的是 y 的引用，但 y 比 s1 先死 → 悬垂引用！编译器无法在编译期确定返回的是 x 还是 y → 需要程序员用生命周期标注来声明关系

生命周期语法 'a

生命周期参数用 'a、'b 等表示，写在 & 后面。它们不改变任何引用的实际生命周期，只是描述引用之间的关系。

Rust

// 告诉编译器：返回值的生命周期至少和 x、y 中较短的一样长
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let s1 = String::from("long string");  // ─── s1 生命周期开始
    let result;
    {
        let s2 = String::from("xyz");       // ─── s2 生命周期开始
        result = longest(s1.as_str(), s2.as_str());
        println!("{}", result);              // ✅ s1 和 s2 都还活着
    }                                        // ─── s2 生命周期结束
    // println!("{}", result);  // ❌ s2 已死，result 可能引用 s2
}

生命周期 'a 的含义 fn longest<'a>(x: &'a str, y: &'a str) -> &'a str 解读： ┌─────────────────────────────────────────────────┐ │ x 活 'a 久 │ │ y 活 'a 久 │ │ 返回值至少活 'a 久 │ │ │ │ 'a = min(x的生命周期, y的生命周期) │ │ 返回值不会比最短的输入活得更久 │ └─────────────────────────────────────────────────┘ 实际上 'a 是调用者约束的，编译器会在每个调用点验证

结构体中的生命周期

结构体如果持有引用，必须标注生命周期——告诉编译器这个引用至少活多久。

✅ 标注生命周期

struct Parser<'a> {
    input: &'a str,
    pos: usize,
}

impl<'a> Parser<'a> {
    fn new(input: &'a str) -> Self {
        Parser { input, pos: 0 }
    }

    fn peek(&self) -> Option<char> {
        self.input[self.pos..]
            .chars().next()
    }
}

❌ 缺少生命周期

struct Parser {
    input: &str,
    pos: usize,
}
// error: missing lifetime specifier
// this struct has a reference field
// which must have a lifetime

💡 经验法则：如果你发现需要在结构体中持有引用，先考虑是否可以用拥有所有权的类型替代（如 String 代替 &str，Vec<T> 代替 &[T]）。持有引用意味着结构体的生命周期受限于引用目标，这会大幅限制灵活性。只在性能关键路径或零拷贝场景中使用引用字段。

生命周期省略规则（Elision Rules）

编译器在简单场景下可以自动推断生命周期，不需要手动标注。三条省略规则：

══════════════════════════════════════════════════ 生命周期省略三规则 ══════════════════════════════════════════════════ 规则1（输入）：每个引用参数获得自己的生命周期 fn foo(x: &str, y: &str) → fn foo<'a, 'b>(x: &'a str, y: &'b str) 规则2（输出）：如果恰好一个输入生命周期，输出同它 fn foo(x: &str) -> &str → fn foo<'a>(x: &'a str) -> &'a str 规则3（方法）：多个输入但含 &self/&mut self，输出同 self fn method(&self, x: &str) -> &str → fn method<'a, 'b>(&'a self, x: &'b str) -> &'a str ══════════════════════════════════════════════════

Rust

// 省略写法（编译器自动推断）
fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

// 等价的完整标注
fn first_word<'a>(s: &'a str) -> &'a str {
    // ...
}

7. 静态生命周期

'static 是一个特殊的生命周期，表示引用在整个程序运行期间都有效。

字符串字面量

Rust

let s: &'static str = "hello world";
// 字符串字面量直接编译进二进制文件，永不过期

'static 的两种含义 ┌──────────────────────────────────────────────────────┐ │ 1. 引用生命周期：引用在整个程序运行期间都有效 │ │ → 字符串字面量存在二进制的 .rodata 段 │ │ → 程序结束前不会回收 │ │ │ │ 2. 泛型约束：T: 'static │ │ → T 不含任何非 'static 的引用 │ │ → T 可以安全地活到程序结束 │ │ → ⚠️ 不等于 T 必须活到程序结束！ │ └──────────────────────────────────────────────────────┘

T: 'static 不等于"永远活着"

⚠️ 常见误解：T: 'static 表示 T 中不含任何短于 'static 的引用，而非 T 本身必须活到程序结束。所有拥有所有权的类型（如 String、Vec<T>）都满足 T: 'static，因为它们不依赖外部引用。

Rust

// String 满足 'static 约束（拥有所有权，无短生命周期引用）
fn takes_static<T: 'static>(t: T) {}

takes_static(String::from("hello"));  // ✅ String: 'static
takes_static(42);                     // ✅ i32: 'static
takes_static("literal");              // ✅ &'static str: 'static

// 但这个不行：
fn bad() {
    let s = String::from("hello");
    let r = &s;
    takes_static(r);  // ❌ &s 不是 'static
}

'static 的典型使用场景

多线程：std::thread::spawn 要求闭包 F: FnOnce() + Send + 'static
全局常量：const 和 static 值必须是 'static
错误类型：impl Error + 'static 确保 std::any::Any downcast 可用

8. 复杂场景

结构体中的多个生命周期

当结构体持有来自不同来源的引用时，需要不同的生命周期参数：

Rust

struct Context<'input, 'config> {
    input: &'input str,      // 输入数据
    config: &'config Config,  // 配置信息
}

impl<'input, 'config> Context<'input, 'config> {
    fn process(&self) -> &'input str {
        // 返回值只关联 input，不受 config 生命周期限制
        self.input
    }
}

多个生命周期的意义时间 ─────────────────────────────────────────▶ config ████████████████████████████████████████ input ████████████ Context ████████████ (input 和 config 的交集) 返回 &'input ████████████ (只绑定 input，不受 config 限制) 分离生命周期 → 返回值不受不相关引用的限制

生命周期约束（Lifetime Bounds）

Rust

// T: 'a 表示 T 中的所有引用至少活 'a
struct RefWrapper<'a, T: 'a> {
    reference: &'a T,
}

// 'a: 'b 表示生命周期 'a 至少和 'b 一样长
fn choose_first<'a, 'b: 'a>(first: &'a str, _second: &'b str) -> &'a str {
    first
}

// where 子句中写约束，更清晰
fn complex<'a, 'b>(
    x: &'a str,
    y: &'b str,
) -> &'a str
where
    'b: 'a,  // 'b 至少和 'a 一样长
{
    x
}

高阶生命周期 Trait Bound（HRTB）

对于闭包和 trait 中的生命周期，有时需要"对所有生命周期都成立"的约束：

Rust

// for<'a> 表示"对所有生命周期 'a"
// 常见于 Fn trait bounds
fn call_with_ref<F>(f: F)
where
    F: for<'a> Fn(&'a i32) -> &'a i32,
{
    let x = 42;
    let result = f(&x);
    println!("{}", result);
}

// 这个闭包满足 for<'a> Fn(&'a i32) -> &'a i32
// 因为它对任意输入引用的生命周期都成立
call_with_ref(|x| x);

⚠️ HRTB 不常用：日常编码中很少需要手写 for<'a>。它主要出现在库的 API 设计中，特别是涉及闭包和回调的场景。如果你遇到了，大概率可以用更简单的方式重写。

9. 常见陷阱

陷阱1：同时持有引用和可变引用

❌ 编译失败

let mut v = vec![1, 2, 3, 4, 5];

let first = &v[0];       // 不可变引用
v.push(6);                 // ❌ 可变借用
// push 可能导致重新分配
// first 可能悬垂！

println!("{}", first);

✅ 解决方案

let mut v = vec![1, 2, 3, 4, 5];

let first = v[0];  // Copy 出来
v.push(6);          // ✅ 没有引用冲突

println!("{}", first);

为什么 push 和 &v[0] 冲突？ push 之前： push 之后（可能重新分配）： ┌──────┐ ┌──────┐ │ v │ │ v │ │ ptr──┼──▶ [1,2,3,4,5] │ ptr──┼──▶ [1,2,3,4,5,6] (新地址) │ cap:5│ │ cap:8│ └──────┘ └──────┘ ▲ 旧内存已释放！ │ first → 💀 悬垂引用 first ─┘ Vec push 可能 realloc → 旧指针悬垂 → 借用规则阻止

陷阱2：自引用结构

Rust

// ❌ 无法直接表达自引用
struct SelfRef {
    data: String,
    pointer: &str,  // 想指向 data，但生命周期怎么写？
}

// 尝试1：生命周期标注
struct SelfRef2<'a> {
    data: String,
    pointer: &'a str,  // 'a 从哪来？
}
// 无法创建！因为 data 的地址在构造后才知道，
// 而 'a 需要在构造时确定

自引用结构在 Rust 中是个经典难题。解决方案：

方案	原理	适用场景
Pin<Box<T>>	保证数据不会被 move	async/await 生成的 Future
索引替代引用	用 usize 索引代替指针	slotmap / arena
owning_ref crate	封装安全的自引用	需要自引用的容器
rental crate	声明式自引用	复杂自引用场景（已弃用）
重新设计	避免自引用	大多数情况下最佳

Rust — 索引替代引用

// 用索引代替引用，绕过生命周期问题
struct SelfRefIndexed {
    data: Vec<String>,
    pointer_idx: usize,  // 指向 data[pointer_idx]
}

impl SelfRefIndexed {
    fn get_ref(&self) -> &str {
        &self.data[self.pointer_idx]
    }
}

陷阱3：循环引用

Rust 的所有权模型天然防止了循环引用导致的内存泄漏——但如果你用 Rc/Arc，循环引用仍然可能发生：

Rc 循环引用导致内存泄漏 ┌──────────┐ │ Node A │ │ Rc(1) │──────────┐ └──────────┘ │ ▲ ▼ │ ┌──────────┐ └────────────│ Node B │ │ Rc(1) │ └──────────┘ A 的引用计数 = 1 (B 引用 A) B 的引用计数 = 1 (A 引用 B) 两者互相引用 → 引用计数永不为 0 → 内存泄漏！

Rust — 用 Weak 打破循环

use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,    // Weak 引用，不增加引用计数
    children: RefCell<Vec<Rc<Node>>>,  // Strong 引用
}

let leaf = Rc::new(Node {
    value: 3,
    parent: RefCell::new(Weak::new()),
    children: RefCell::new(vec![]),
});

let branch = Rc::new(Node {
    value: 5,
    parent: RefCell::new(Weak::new()),
    children: RefCell::new(vec![Rc::clone(&leaf)]),
});

*leaf.parent.borrow_mut() = Rc::downgrade(&branch);
// branch → leaf (Strong)
// leaf → branch (Weak) → 不阻止 branch 被释放

Weak 打破循环 ┌──────────┐ │ branch │ │ Rc(1) │────────── Strong └──────────┘ │ ▲ ▼ │ ┌──────────┐ Weak │ leaf │ (不增加计数) │ Rc(1) │ └──────────┘ branch 的引用计数 = 1（只有外部变量持有）外部 branch 离开作用域 → branch 被释放 → leaf 的 Weak 变成 None

陷阱4：结构体更新语法中的 Move

Rust

struct User {
    name: String,
    email: String,
    active: bool,
}

let user1 = User {
    name: String::from("Alice"),
    email: String::from("alice@example.com"),
    active: true,
};

// 结构体更新语法会 move 字段！
let user2 = User {
    name: String::from("Bob"),
    ..user1  // email 和 active 从 user1 move 过来
};

// println!("{}", user1.email);  // ❌ email 已被 move
println!("{}", user1.name);      // ✅ name 没被 move（user2 显式提供了）
println!("{}", user1.active);    // ✅ bool 是 Copy 类型

10. 实战：实现一个简单的 String 类型

通过从零实现一个简化版 MyString，深入理解所有权、move、drop 的底层机制。

第一步：定义结构

Rust

use std::alloc::{alloc, dealloc, realloc, Layout};
use std::ptr::{self, copy_nonoverlapping};
use std::ops::{Deref, DerefMut};
use std::fmt;

pub struct MyString {
    ptr: *mut u8,     // 指向堆上数据的指针
    len: usize,       // 当前长度
    cap: usize,       // 容量
}

impl MyString {
    /// 从 &str 创建 MyString
    pub fn from_str(s: &str) -> Self {
        let len = s.len();
        let cap = len.max(1);  // 至少分配 1 字节
        let layout = Layout::array::<u8>(cap).unwrap();

        let ptr = unsafe { alloc(layout) };
        if ptr.is_null() {
            panic!("allocation failed");
        }

        // 复制数据到堆
        unsafe {
            copy_nonoverlapping(s.as_ptr(), ptr, len);
        }

        MyString { ptr, len, cap }
    }

    /// 返回字符串切片
    pub fn as_str(&self) -> &str {
        // 安全：ptr..ptr+len 之间的数据是有效的 UTF-8
        unsafe {
            let slice = std::slice::from_raw_parts(self.ptr, self.len);
            std::str::from_utf8_unchecked(slice)
        }
    }

    /// 追加字符串
    pub fn push_str(&mut self, s: &str) {
        let new_len = self.len + s.len();
        if new_len > self.cap {
            self.grow(new_len);
        }
        unsafe {
            copy_nonoverlapping(
                s.as_ptr(),
                self.ptr.add(self.len),
                s.len(),
            );
        }
        self.len = new_len;
    }

    /// 扩容
    fn grow(&mut self, min_cap: usize) {
        let new_cap = min_cap.max(self.cap * 2);
        let old_layout = Layout::array::<u8>(self.cap).unwrap();
        let new_layout = Layout::array::<u8>(new_cap).unwrap();

        let new_ptr = unsafe { realloc(self.ptr, old_layout, new_layout.size()) };
        if new_ptr.is_null() {
            panic!("reallocation failed");
        }
        self.ptr = new_ptr;
        self.cap = new_cap;
    }
}

第二步：实现 Drop — 自动释放

Rust

impl Drop for MyString {
    fn drop(&mut self) {
        // 释放堆内存
        let layout = Layout::array::<u8>(self.cap).unwrap();
        unsafe {
            dealloc(self.ptr, layout);
        }
        // self.ptr 现在是悬垂指针，但 MyString 即将被销毁
        // 不会有代码再访问它
    }
}

// Drop 被自动调用：
fn demo() {
    let s = MyString::from_str("hello");
    // ... 使用 s ...
}   // ← 这里自动调用 s.drop()

第三步：理解 Move 的关键

MyString 没有实现 Copy，这意味着赋值是 move：

Rust

let s1 = MyString::from_str("hello");
let s2 = s1;  // move！

// s1 现在无效！如果 s1 还能用，s1 和 s2 的 drop 都会释放同一块内存
// → double free → 未定义行为

// Rust 编译器阻止你使用 s1：
// println!("{:?}", s1);  // ❌ use of moved value

Move 为什么是默认行为？如果赋值是复制（深拷贝）： ┌──────────┐ ┌─────────────┐ │ s1 │ │ h e l l o │ │ ptr ────┼───────────────▶│ │ └──────────┘ └─────────────┘ ┌──────────┐ ┌─────────────┐ │ s2 │ │ h e l l o │ ← 浪费！ │ ptr ────┼───────────────▶│ (拷贝) │ 每次赋值都深拷贝 └──────────┘ └─────────────┘ 性能很差如果赋值是浅拷贝（像 C++ 的浅拷贝）： ┌──────────┐ ┌─────────────┐ │ s1 │ ┌───▶ │ h e l l o │ │ ptr ────┼────┐ │ │ │ └──────────┘ │ │ └─────────────┘ ┌──────────┐ │ │ ▲ │ s2 │ │ └────────────┤ │ ptr ────┼────┘ │ └──────────┘ double free！两个 drop 都会释放 Rust 的 Move：浅拷贝 + 使原变量失效 ┌──────────┐ ┌─────────────┐ │ s1 │ ╳ 失效 │ h e l l o │ │ (moved) │ │ │ └──────────┘ └─────────────┘ ┌──────────┐ ▲ │ s2 │ │ │ ptr ────┼─────────────────────┘ └──────────┘ 只有一个 owner → 只会 drop 一次 → 安全且高效

第四步：实现 Clone

Rust

impl Clone for MyString {
    fn clone(&self) -> Self {
        // 深拷贝：分配新的堆内存，复制数据
        MyString::from_str(self.as_str())
    }
}

// 现在 clone() 可用：
let s1 = MyString::from_str("hello");
let s2 = s1.clone();  // 显式深拷贝
// s1 和 s2 都有效，各自拥有独立的堆内存

第五步：完整实现概览

Rust

impl fmt::Display for MyString {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl Deref for MyString {
    type Target = str;
    fn deref(&self) -> &Self::Target {
        self.as_str()
    }
}

impl DerefMut for MyString {
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe {
            let slice = std::slice::from_raw_parts_mut(self.ptr, self.len);
            std::str::from_utf8_unchecked_mut(slice)
        }
    }
}

// Deref 让 MyString 可以像 &str 一样使用：
fn demo() {
    let mut s = MyString::from_str("hello");
    s.push_str(", world");
    println!("{}", s);              // Display
    println!("len = {}", s.len());  // Deref 到 str 的 len()
    assert!(s.starts_with("hello")); // Deref 到 str 的方法
}

✅ 要点回顾：通过实现 MyString，我们看到了所有权系统的完整闭环——alloc 分配堆内存，Drop 自动释放，Move 防止 double free，Clone 允许显式深拷贝。标准库的 String 做的也是这些事，只是更完善（处理了零大小类型、对齐等边界情况）。

🎯 核心要点总结

3

所有权规则

2

引用类型 &T / &mut T

1

借用原则：多读或一写

3

生命周期省略规则

════════════════════════════════════════════════════════════ 所有权思维导图 ════════════════════════════════════════════════════════════ 所有权系统 ┌───────┴───────┐ │ │ 所有权借用 ┌────┴────┐ ┌─────┴─────┐ │ │ │ │ Move Copy &T &mut T │ │ │ │ 非 Copy Copy 多个读唯一写类型类型同时OK 同时刻只有一个赋值= 赋值= 转移复制生命周期 'a ┌───────┴───────┐ │ │ 省略规则显式标注 (自动推断) (复杂场景) │ │ 输入→输出函数/结构体/ self→返回多生命周期约束 ════════════════════════════════════════════════════════════

🔒 所有权与借用

📑 目录

1. 为什么需要所有权

C/C++ 的困境：自由代价高昂

Go/Java 的困境：安全的代价是运行时

Rust 的第三条路：编译期所有权检查

2. 所有权规则

规则1：每个值只有一个 owner

规则2：赋值是转移（Move），不是复制

✅ 可以编译

❌ 编译失败

规则3：离开作用域自动释放

与 C++ 的对比

3. Move语义详解

String 的 Move

栈数据的 Copy 语义

哪些类型实现了 Copy？

clone()：显式深拷贝

函数传参的 Move

✅ Copy 类型传参

❌ 非 Copy 类型传参

4. 借用与引用

不可变引用 &T

可变引用 &mut T

借用规则：Rust 最重要的安全保证

✅ 多个不可变引用

❌ 可变 + 不可变引用

❌ 多个可变引用

✅ 非重叠的作用域

NLL（Non-Lexical Lifetimes）

与 Go 的对比

5. 悬垂引用

编译器如何阻止悬垂引用

✅ 返回拥有所有权的值

❌ 返回局部变量的引用

与 C++ 的对比

6. 生命周期标注

为什么需要生命周期标注

生命周期语法 'a

结构体中的生命周期

✅ 标注生命周期

❌ 缺少生命周期

生命周期省略规则（Elision Rules）

7. 静态生命周期

字符串字面量

T: 'static 不等于"永远活着"

'static 的典型使用场景

8. 复杂场景

结构体中的多个生命周期

生命周期约束（Lifetime Bounds）

高阶生命周期 Trait Bound（HRTB）

9. 常见陷阱

陷阱1：同时持有引用和可变引用

❌ 编译失败

✅ 解决方案

陷阱2：自引用结构

陷阱3：循环引用

陷阱4：结构体更新语法中的 Move

10. 实战：实现一个简单的 String 类型

第一步：定义结构

第二步：实现 Drop — 自动释放

第三步：理解 Move 的关键

第四步：实现 Clone

第五步：完整实现概览

🎯 核心要点总结