《Rust编程入门》6.1 所有权的基本概念

6.1 所有权的基本概念

所有权是 Rust 的核心特性之一，它在 Rust 中起着非常重要的作用，直接影响着内存管理、性能和安全性。所有权在 Rust 中通过一套严格的规则来控制内存的分配和释放，从而避免了许多常见的内存错误，如空指针解引用、内存泄漏等。

6.1.1 所有权规则

Rust 的所有权机制基于三个基本规则：

1. 每个值都有一个变量作为它的“所有者”。

   • 这个变量负责管理该值的生命周期。
   • 当所有者超出作用域时，Rust 会自动清理该值。

2. 每个值只能有一个所有者。

   • 在任何时刻，一个值只能有一个所有者，这确保了内存不会被多次释放。
   • 这种规则避免了多次释放同一内存区域的错误。

3. 当所有者离开作用域时，值会被删除。

   • Rust 使用一种名为“析构”的机制，确保在不再需要某个值时自动释放其占用的内存。

示例：基本所有权

1
2
3
4
5
6
7

fn main() {
    let s1 = String::from("Hello");  // s1 是 String 的所有者
    let s2 = s1;  // s2 获取了 s1 的所有权，s1 不再有效

    // println!("{}", s1);  // 错误：s1 的所有权已转移给 s2，不能再使用 s1
    println!("{}", s2);  // 输出：Hello
}

在这个示例中，s1 将 String 类型的数据的所有权转移给了 s2。此时，s1 不再拥有这个值，因此不能再使用 s1 变量。Rust 的所有权转移（或称为“移动”）操作保证了不会发生内存泄漏或悬挂引用。

6.1.2 所有权转移（Move）与复制（Copy）

Rust 中有两种主要的所有权处理方式：转移（move） 和 复制（copy）。

转移（Move）

在默认情况下，Rust 会在赋值时发生所有权转移，也就是值被“移动”到新的变量中。原始变量将不再有效。

1
2
3
4
5
6
7

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

    // println!("{}", s1);  // 错误：s1 不再有效
    println!("{}", s2); // 输出：Hello
}

在上面的代码中，s1 的所有权被移动到 s2。这意味着 s1 变量不再能访问该数据，Rust 会通过编译器的所有权规则来确保内存安全。

复制（Copy）

某些类型实现了 Copy 特性，意味着在赋值时不会发生所有权转移，而是会将数据的副本复制到新变量中。比如整数类型（i32, i64 等）和浮点数类型（f32, f64）等。

1
2
3
4
5
6
7

fn main() {
    let x = 42; // 整数类型实现了 Copy 特性
    let y = x;  // y 复制了 x 的值

    println!("{}", x); // 输出：42
    println!("{}", y); // 输出：42
}

在上面的代码中，x 的值被复制给了 y，x 依然有效，不会被移除。

实现 Copy 特性的类型

Rust 中，Copy 特性通常适用于那些存储在栈上的简单数据类型（如整数、浮点数、字符等）。这类数据类型无需进行深拷贝，它们的大小和复杂性使得简单的复制操作更加高效。

6.1.3 值的生命周期与作用域

Rust 的所有权规则与作用域紧密相关。每个变量在其作用域内持有它所拥有的值。当变量超出作用域时，Rust 会自动清理掉它所拥有的资源，释放内存。

1
2
3
4

fn main() {
    let s = String::from("Hello");  // s 是所有者，s 的作用域从此处开始
    println!("{}", s); // 输出：Hello
}  // s 超出作用域，内存被自动释放

在上面的例子中，当 s 离开作用域时，Rust 会自动调用 drop 函数释放内存，确保没有资源泄漏。

析构函数

Rust 自动为没有再被引用的资源调用析构函数，从而清理内存。例如，String 类型在超出作用域时会自动调用 drop 方法释放内存。

6.1.4 所有权与函数

当一个变量传递给函数时，它的所有权会发生变化，除非是使用引用（借用）。这也意味着当函数结束时，所有权会回到调用者，或者发生转移。

传递所有权：

1
2
3
4
5
6
7
8
9

fn take_ownership(s: String) {
    println!("{}", s); // 这里 s 是函数的所有者
}

fn main() {
    let s1 = String::from("Hello");
    take_ownership(s1); // 所有权转移到函数
    // println!("{}", s1);  // 错误：s1 的所有权已转移，不能再访问
}

返回所有权：

1
2
3
4
5
6
7
8
9

fn give_ownership() -> String {
    let s = String::from("Hello");
    s // 返回所有权
}

fn main() {
    let s1 = give_ownership();
    println!("{}", s1); // 输出：Hello
}

6.1.5 小结

• 所有权 是 Rust 的一个核心概念，它使得 Rust 可以在编译时确保内存安全。
• 每个值在 Rust 中有一个所有者，且在任何时刻只能有一个所有者。
• 所有权转移 是 Rust 中的默认行为，而实现 Copy 特性的数据类型可以通过值的复制而不是转移。
• 作用域 决定了变量的生命周期，一旦变量超出作用域，Rust 会自动清理其所占用的内存。

下一节将深入探讨 借用与引用规则，了解如何通过借用机制避免所有权的转移，并保持内存的安全性和灵活性。

• Rust
• Rust Tutors
• Rust编程入门