上一篇我们学习了函数、表达式和控制流，这一篇将正式进入 Rust 最核心、最独特的语言机制：所有权系统。

一、为什么需要所有权机制？

在 C/C++ 中，内存管理依赖开发者手动操作，容易出现 野指针、重复释放、内存泄漏 等问题。而 Java/Python/Go 虽然使用垃圾回收器（GC）自动管理内存，但可能带来运行时性能开销。

Rust 则提出了独特的"所有权机制"，在编译阶段完成大部分内存安全检查，无需 GC，也不会有悬垂指针，保证了性能和安全。

二、所有权（Ownership）

1. 栈与堆

在讨论所有权之前，我们需要理解 Rust 中的两种内存：

• 栈（Stack）：固定大小，快速访问，后进先出
• 堆（Heap）：动态大小，较慢访问，需要分配和释放

// 栈上数据
let x = 5; // 整数在栈上
let y = x; // 复制值，两个独立的数据

// 堆上数据
let s1 = String::from("hello");  // 字符串在堆上
let s2 = s1;                     // 移动所有权，s1 失效
// println!("{}", s1); //  错误：s1 已经被移动

2. 所有权规则

Rust 的内存管理基于三条所有权规则：

1. 每个值都有一个所有者（owner）
2. 同一时间，值只能有一个所有者
3. 当所有者离开作用域，值会被自动释放（drop）

3. Copy Trait

实现了 Copy trait 的类型在赋值时会复制值而不是移动所有权：

// 实现了 Copy 的类型
let x = 5;
let y = x; // x 仍然有效
println!("x = {}, y = {}", x, y);

// 没有实现 Copy 的类型
let s1 = String::from("hello");
let s2 = s1; // s1 的所有权被移动
// println!("{}", s1); //  错误：s1 已无效

常见的 Copy 类型：

• 所有整数类型（如 i32、u32）
• 布尔类型（bool）
• 浮点类型（f64、f32）
• 字符类型（char）
• 包含以上类型的元组（如 (i32, i32)）

4. 所有权转移（Move）

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // 所有权转移，s1 不再有效

    // println!("{}", s1); //  编译错误：s1 已无效
    println!("{}", s2); // 
}

所有权转移的其他场景：

// 函数参数
fn take_ownership(s: String) {
    println!("{}", s);
} // s 在这里离开作用域并被释放

// 函数返回值
fn give_ownership() -> String {
    let s = String::from("hello");
    s // 返回 s 的所有权
}

// 结构体字段
struct Person {
    name: String,
    age: i32,
}

let p1 = Person {
    name: String::from("Alice"),
    age: 30,
};
let p2 = p1; // p1 的所有权被移动
// println!("{}", p1.name); //  错误：p1 已无效

三、借用（Borrowing）

如果你不想转移所有权，而只是临时使用，可以 借用：

fn main() {
    let s = String::from("hello");
    print_str(&s);     // 借用，不转移所有权
    println!("{}", s); //  s 仍然有效
}

fn print_str(s: &String) {
    println!("{}", s);
}

借用使用 & 引用符号。此处为不可变引用，意味着你不能在 print_str 中修改 s 的值。

借用检查器

Rust 的借用检查器在编译时确保所有借用都是安全的，它可以智能地判断引用的实际使用范围，而不是简单地按照词法作用域来判断。

fn main() {
    let mut s = String::from("hello");
    
    let r1 = &s; // 不可变借用
    let r2 = &s; // 另一个不可变借用
    println!("{} and {}", r1, r2);  // r1 和 r2 的最后一次使用
    // Rust 的借用检查器基于非词法生命周期（Non-Lexical Lifetimes）
    // 使得引用的有效作用域精确到最后一次使用的位置，而非整个词法作用域
   
    let r3 = &mut s; //  现在可以创建可变引用
    println!("{}", r3);
}

借用规则

不可变借用规则：

1. 可以同时有多个不可变借用
2. 不可变借用期间，数据不能被修改

fn main() {
    let s = String::from("hello");
    let r1 = &s;
    let r2 = &s;
    // s.push_str(" world"); //  错误：不能在有不可变借用时修改数据
    println!("{} and {}", r1, r2);
}

可变借用规则：

1. 同一时间只能有一个可变借用
2. 可变借用期间，不能有其他借用（可变或不可变）

fn main() {
    let mut s = String::from("hello");
    let r1 = &mut s;
    // let r2 = &mut s; //  错误：不能同时有多个可变借用
    // let r3 = &s;     //  错误：不能在有可变借用时进行不可变借用
    r1.push_str(" world");
}

借用作用域：

1. 借用的作用域从声明开始，到最后一次使用结束
2. 这允许在同一个作用域内进行多个借用，只要它们不重叠使用

fn main() {
    let mut s = String::from("hello");
    
    {
        let r1 = &s;
        println!("{}", r1);
    } // r1 的作用域结束
    
    let r2 = &mut s;  //  正确：r1 已经不再使用
    r2.push_str(" world");
}

四、可变借用（Mutable Borrow）

默认引用是不可变的，但你也可以创建可变引用：

fn main() {
    let mut s = String::from("hello");
    change(&mut s);
    println!("{}", s); //  输出: hello, world
}

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

可变借用规则：

• 同一时间，只能有一个可变引用
• 或，多个不可变引用，但不能与可变引用共存

这样能避免数据竞争（Data Race）问题。

五、悬垂引用与生命周期（简介）

Rust 编译器必须确保引用永远不会悬空。例如：

fn dangle() -> &str {
    let s = String::from("hello");
    &s[..] //  错误：s 被释放了，返回了无效引用
}

编译器会拒绝这种写法，防止悬垂指针。

生命周期标注

生命周期标注是编译器判断引用有效范围的一种方式：

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

• 'a 是生命周期参数
• 表示返回的引用不能超过参数 x 或 y 中较短的生命周期，必须在两者中较小的生命周期内使用

生命周期省略规则

Rust 编译器可以自动推断一些常见的生命周期标注：

1. 每个引用参数都有自己的生命周期参数
2. 如果只有一个输入生命周期参数，它被赋给所有输出生命周期参数
3. 如果有多个输入生命周期参数，但其中一个是 &self 或 &mut self，则 self 的生命周期被赋给所有输出生命周期参数

// 这些函数签名是等价的
fn first_word(s: &str) -> &str { ... } // 编译器自动添加生命周期
fn first_word<'a>(s: &'a str) -> &'a str { ... } // 显式标注

结构体中的生命周期

当结构体包含引用时，需要标注生命周期：

struct Excerpt<'a> {
    part: &'a str,
}

fn main() {
    let novel = String::from("从前有座山，山里有座庙，庙里有个老和尚在讲故事...");
    let first_sentence = novel.split('.').next().expect("找不到第一个句子");
    let i = Excerpt {
        part: first_sentence,
    };
}

静态生命周期

'static 表示引用在整个程序运行期间都有效：

let s: &'static str = "I have a static lifetime.";

六、练习题（动手最重要）

1. 创建一个 String 类型的变量，将它赋值给另一个变量后，尝试打印原变量，看看编译器如何报错？
2. 实现一个函数，接收一个字符串引用，打印它的内容
3. 实现一个函数，接收一个可变引用，修改字符串内容
4. 尝试创建两个可变引用，会发生什么？
5. 思考：你认为为什么 Rust 要强制借用规则？

七、小结

Rust 的所有权系统虽然一开始可能让人觉得繁琐，但它正是保证 Rust 高性能与内存安全的核心机制。掌握所有权、借用与生命周期，是通往 Rust 世界的必经之路。

下一篇预告

下一篇我们将继续探索 模式匹配之流程控制，构建更复杂的数据结构与逻辑分支。

欢迎关注、收藏和转发，也可以留言你最想了解的内容，有任何问题可以留言或私信，我会尽力解答！

喜欢编程、区块链、Web3

可加好友