《Rust快速入门》5. 所有权与借用

January 18, 2025

所有权与借用：Rust 内存安全的核心机制

Rust 是一门以内存安全和高性能著称的系统编程语言。其独特的所有权系统是 Rust 实现内存安全的核心机制之一。通过所有权系统，Rust 在编译时就能避免常见的内存错误，如空指针、数据竞争等。本文将详细介绍 Rust 的所有权机制、借用规则以及生命周期，并通过完整的代码示例和详尽的指导过程帮助读者深入理解这些概念。

1. 所有权机制

1.1 什么是所有权？

所有权是 Rust 的核心特性之一，它规定了程序中值的生命周期和内存管理方式。Rust 的所有权规则如下：

每个值都有一个所有者：每个值在 Rust 中都有一个变量作为其所有者。
同一时间只能有一个所有者：一个值不能同时被多个变量拥有。
当所有者离开作用域时，值会被自动释放：Rust 会自动调用值的析构函数（drop）来释放内存。

这些规则确保了 Rust 在编译时就能避免内存泄漏和悬空指针等问题。

1.2 所有权的基本规则

示例 1：所有权的转移

1
2
3
4
5
6
7


fn main() {
    let s1 = String::from("hello"); // s1 是字符串 "hello" 的所有者
    let s2 = s1; // s1 的所有权转移给 s2

    // println!("{}", s1); // 错误：s1 不再拥有值
    println!("{}", s2); // 正确：s2 现在是所有者
}

解释：

let s1 = String::from("hello"); 创建了一个 String 类型的值，并将其所有权赋予变量 s1。
let s2 = s1; 将 s1 的所有权转移给 s2。此时，s1 不再拥有该值，因此尝试访问 s1 会导致编译错误。
Rust 的所有权转移机制确保了同一时间只有一个变量拥有值的所有权。

示例 2：函数中的所有权转移

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


fn take_ownership(s: String) {
    println!("{}", s);
} // s 离开作用域，值被释放

fn main() {
    let s = String::from("hello");
    take_ownership(s); // s 的所有权转移给函数参数

    // println!("{}", s); // 错误：s 不再拥有值
}

解释：

take_ownership(s); 将 s 的所有权转移给函数参数 s。
函数执行完毕后，s 离开作用域，值被自动释放。
由于所有权已经转移，main 函数中的 s 不再有效。

示例 3：返回值的所有权

1
2
3
4
5
6
7
8
9


fn give_ownership() -> String {
    let s = String::from("hello");
    s // 返回 s，所有权转移给调用者
}

fn main() {
    let s = give_ownership(); // s 获得返回值的所有权
    println!("{}", s);
}

解释：

give_ownership 函数返回一个 String 类型的值，所有权转移给调用者。
let s = give_ownership(); 中，s 获得了返回值的所有权。

1.3 克隆数据：避免所有权转移

如果希望保留原始值的所有权，可以使用 clone 方法创建一个值的深拷贝。

1
2
3
4
5
6


fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone(); // 克隆 s1 的值

    println!("s1 = {}, s2 = {}", s1, s2); // 正确：s1 和 s2 都有效
}

解释：

let s2 = s1.clone(); 创建了 s1 的深拷贝，s1 和 s2 分别拥有独立的所有权。
克隆操作会消耗更多的内存和计算资源，因此应谨慎使用。

1.4 栈上的数据：复制语义

对于实现了 Copy trait 的类型（如整数、布尔值等），赋值操作会复制值而不是转移所有权。

1
2
3
4
5
6


fn main() {
    let x = 5;
    let y = x; // x 的值被复制给 y

    println!("x = {}, y = {}", x, y); // 正确：x 和 y 都有效
}

解释：

let y = x; 复制了 x 的值，而不是转移所有权。
基本类型（如 i32、bool 等）默认实现了 Copy trait。

2. 借用与引用

2.1 什么是借用？

借用是 Rust 中允许访问值而不获取其所有权的机制。通过引用（&），可以借用值的所有权而不转移它。

示例 1：不可变引用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // 借用 s1 的引用

    println!("The length of '{}' is {}.", s1, len); // 正确：s1 仍然有效
}

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

解释：

&s1 创建了一个对 s1 的不可变引用。
calculate_length(&s1); 将 s1 的引用传递给函数，函数可以访问值但不能修改它。
由于没有转移所有权，s1 在函数调用后仍然有效。

示例 2：可变引用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


fn main() {
    let mut s = String::from("hello");
    change(&mut s); // 借用 s 的可变引用

    println!("{}", s); // 正确：s 被修改为 "hello, world"
}

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

解释：

&mut s 创建了一个对 s 的可变引用。
change(&mut s); 将 s 的可变引用传递给函数，函数可以修改值。
可变引用允许修改值，但同一时间只能有一个可变引用。

2.2 借用规则

Rust 的借用规则确保了内存安全：

同一时间只能有一个可变引用：防止数据竞争。
不可变引用和可变引用不能同时存在：防止数据不一致。

示例 3：违反借用规则

1
2
3
4
5
6
7
8


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

    let r1 = &mut s;
    let r2 = &mut s; // 错误：同一时间只能有一个可变引用

    // println!("{}, {}", r1, r2);
}

解释：

let r1 = &mut s; 创建了一个可变引用 r1。
let r2 = &mut s; 尝试创建第二个可变引用 r2，违反了借用规则。

示例 4：作用域与引用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


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

    {
        let r1 = &mut s;
        println!("{}", r1);
    } // r1 离开作用域

    let r2 = &mut s; // 正确：r1 已经离开作用域
    println!("{}", r2);
}

解释：

r1 的作用域在 {} 内，离开作用域后，r1 不再有效。
let r2 = &mut s; 可以创建新的可变引用。

3. 生命周期

3.1 什么是生命周期？

生命周期是 Rust 中用于确保引用有效的机制。它描述了引用的有效范围，防止悬空引用。

示例 1：悬空引用

1
2
3
4
5
6
7
8


fn main() {
    let r;
    {
        let x = 5;
        r = &x; // x 的生命周期结束
    }
    // println!("{}", r); // 错误：r 是悬空引用
}

解释：

r 试图引用 x，但 x 的生命周期在 {} 内结束。
Rust 编译器会检测到悬空引用并报错。

示例 2：生命周期注解

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


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("hello");
    let s2 = "world";

    let result = longest(&s1, &s2);
    println!("The longest string is {}", result);
}

解释：

'a 是生命周期注解，表示 x 和 y 的生命周期至少与 'a 一样长。
longest 函数返回的引用的生命周期与输入引用的生命周期相同。

4. 综合示例

以下是一个综合示例，展示了所有权、借用和生命周期的结合使用：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


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

    let result = longest(&s1, &s2);
    println!("The longest string is {}", result);
}

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

解释：

longest 函数接受两个字符串引用，并返回较长的字符串引用。
生命周期注解 'a 确保了返回的引用的有效性。

5. 总结

Rust 的所有权、借用和生命周期机制是其内存安全的核心。通过所有权规则，Rust 在编译时避免了内存泄漏和悬空指针；通过借用规则，Rust 防止了数据竞争；通过生命周期注解，Rust 确保了引用的有效性。掌握这些概念是编写高效、安全的 Rust 程序的关键。