跳到主要内容

所有权（Ownership）

所有权（Ownership）是 Rust 最为与众不同的特性，它让 Rust 无需垃圾回收器即可保障内存安全。

什么是所有权？​

所有权是 Rust 用于管理内存的一套规则。所有程序都必须管理其运行时使用计算机内存的方式。一些语言中具有垃圾回收机制，在程序运行时不断地寻找不再使用的内存；在另一些语言中，程序员必须亲自分配和释放内存。Rust 则选择了第三种方式：通过所有权系统管理内存，编译器在编译时会根据一系列的规则进行检查。

所有权规则​

Rust 的所有权有以下规则：

  1. Rust 中的每一个值都有一个所有者（owner）
  2. 值在任一时刻有且只有一个所有者
  3. 当所有者（变量）离开作用域，这个值将被丢弃

变量作用域​

作用域是一个项（item）在程序中有效的范围：

fn main() {
    {                      // s 在这里无效，它尚未声明
        let s = "hello";   // 从此处起，s 是有效的

        // 使用 s
        println!("{}", s);
    }                      // 此作用域已结束，s 不再有效
}

String 类型​

为了演示所有权规则，我们需要一个比基本数据类型更复杂的数据类型。String 类型管理被分配到堆上的数据：

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

    s.push_str(", world!"); // push_str() 在字符串后追加字面值

    println!("{}", s); // 将打印 `hello, world!`
}

内存与分配​

就字符串字面值来说，我们在编译时就知道其内容，所以文本被直接硬编码进最终的可执行文件中。但是对于 String 类型，为了支持一个可变、可增长的文本片段，需要在堆上分配一块在编译时未知大小的内存来存放内容。

这意味着：

  • 必须在运行时向内存分配器（memory allocator）请求内存
  • 需要一个当我们处理完 String 时将内存返回给分配器的方法

移动（Move）​

在 Rust 中，多个变量可以采用不同的方式与同一数据进行交互：

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

    // println!("{}, world!", s1); // 这行代码会编译错误！
    println!("{}, world!", s2); // 这是正确的
}

当我们将 s1 赋给 s2，String 的数据被复制了，这意味着我们从栈上拷贝了它的指针、长度和容量。我们并没有复制指针指向的堆上数据。

为了确保内存安全，在 let s2 = s1 之后，Rust 认为 s1 不再有效，因此 Rust 不需要在 s1 离开作用域后清理任何东西。这个操作被称为移动（move）。

移动的关键特性：一个值只能移动一次​

这是 Rust 所有权系统的核心规则：一个值只能被移动一次。一旦值被移动，原来的变量就不能再使用了。

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;  // s1 的值移动到 s2

    // 编译错误！s1 已经被移动，不能再使用
    // println!("{}", s1);  // ❌ 错误：borrow of moved value: `s1`

    println!("{}", s2);  // ✅ 正确：s2 拥有这个值
}

尝试多次移动会发生什么？​

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;  // 第一次移动：s1 -> s2

    // 尝试再次移动已经被移动的值
    // let s3 = s1;  // ❌ 编译错误！s1 已经无效

    let s3 = s2;  // ✅ 正确：现在从 s2 移动到 s3

    // 现在 s2 也不能使用了
    // println!("{}", s2);  // ❌ 编译错误！s2 已经被移动

    println!("{}", s3);  // ✅ 只有 s3 可以使用
}

函数调用中的移动​

fn take_ownership(s: String) {
    println!("接收到: {}", s);
}

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

    take_ownership(s1);  // s1 被移动到函数中

    // s1 已经被移动，不能再使用
    // println!("{}", s1);  // ❌ 编译错误！

    // 如果想再次使用，需要重新创建
    let s2 = String::from("world");
    take_ownership(s2);

    // s2 也被移动了，不能再使用
    // println!("{}", s2);  // ❌ 编译错误！
}

移动链：值可以在多个变量间传递​

虽然一个值只能移动一次，但可以形成移动链：

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;  // s1 -> s2
    let s3 = s2;  // s2 -> s3
    let s4 = s3;  // s3 -> s4

    // 只有最后的 s4 可以使用
    println!("{}", s4);

    // 前面的变量都不能使用了
    // println!("{}", s1);  // ❌ 错误
    // println!("{}", s2);  // ❌ 错误
    // println!("{}", s3);  // ❌ 错误
}

为什么这样设计？​

这种"只能移动一次"的设计有重要意义：

  1. 防止双重释放：确保内存只被释放一次
  2. 防止悬垂指针：移动后的变量不能访问已释放的内存
  3. 内存安全：在编译时就能发现潜在的内存错误
// 如果允许多次使用已移动的值，会发生什么？
fn main() {
    let s1 = String::from("hello");
    let s2 = s1;  // 假设 s1 仍然可用

    // 当 s1 和 s2 都离开作用域时，
    // 它们都会尝试释放同一块内存 -> 双重释放错误！
    // Rust 通过移动语义避免了这个问题
}

克隆（Clone）​

如果我们确实需要深度复制 String 中堆上的数据，而不仅仅是栈上的数据，可以使用一个叫做 clone 的通用函数：

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

    println!("s1 = {}, s2 = {}", s1, s2);
}

只在栈上的数据：拷贝​

fn main() {
    let x = 5;
    let y = x;

    println!("x = {}, y = {}", x, y);
}

这段代码似乎与我们刚刚学到的内容相矛盾：没有调用 clone，不过 x 依然有效且没有被移动到 y 中。

原因是像整型这样的在编译时已知大小的类型被整个存储在栈上，所以拷贝其实际的值是快速的。这意味着没有理由在创建变量 y 后使 x 无效。

Rust 有一个叫做 Copy trait 的特殊注解，可以用在类似整型这样的存储在栈上的类型上。如果一个类型实现了 Copy trait，那么一个旧的变量在将其赋值给其他变量后仍然可用。

所有权与函数​

将值传递给函数在语义上与给变量赋值相似。向函数传递值可能会移动或者复制，就像赋值语句一样：

fn main() {
    let s = String::from("hello");  // s 进入作用域

    takes_ownership(s);             // s 的值移动到函数里...
                                    // ... 所以到这里不再有效

    let x = 5;                      // x 进入作用域

    makes_copy(x);                  // x 应该移动函数里，
                                    // 但 i32 是 Copy 的，
                                    // 所以在后面可继续使用 x

} // 这里, x 先移出了作用域，然后是 s。但因为 s 的值已经被移动了，
  // 没有特殊之处

fn takes_ownership(some_string: String) { // some_string 进入作用域
    println!("{}", some_string);
} // 这里，some_string 移出作用域并调用 `drop` 方法。
  // 占用的内存被释放

fn makes_copy(some_integer: i32) { // some_integer 进入作用域
    println!("{}", some_integer);
} // 这里，some_integer 移出作用域。没有特殊之处

重要澄清：关键在于 Copy trait，不是可变性​

常见误解：认为不可变的值传递给函数后仍然可用。

正确理解：是否可以在函数调用后继续使用，取决于类型是否实现了 Copy trait，与可变性无关。

fn main() {
    // 不可变的 String - 会被移动
    let s1 = String::from("hello");        // 不可变
    takes_string(s1);
    // println!("{}", s1);  // ❌ 错误！s1 已被移动，即使它是不可变的

    // 可变的 String - 也会被移动
    let mut s2 = String::from("world");    // 可变
    takes_string(s2);
    // println!("{}", s2);  // ❌ 错误！s2 也被移动了，即使它是可变的

    // 不可变的 i32 - 会被复制
    let x = 5;                             // 不可变
    takes_integer(x);
    println!("{}", x);    // ✅ 正确！x 仍然可用，因为 i32 实现了 Copy

    // 可变的 i32 - 也会被复制
    let mut y = 10;                        // 可变
    takes_integer(y);
    println!("{}", y);    // ✅ 正确！y 仍然可用，因为 i32 实现了 Copy
}

fn takes_string(s: String) {
    println!("接收字符串: {}", s);
}

fn takes_integer(n: i32) {
    println!("接收整数: {}", n);
}

Copy trait 类型 vs 非 Copy trait 类型​

实现了 Copy trait 的类型（会被复制）：​

fn main() {
    // 这些类型实现了 Copy trait，传递给函数时会被复制
    let a = 5;           // i32
    let b = 3.14;        // f64
    let c = true;        // bool
    let d = 'A';         // char
    let e = (1, 2);      // 元组（如果所有元素都是 Copy 的）

    use_copy_types(a, b, c, d, e);

    // 所有变量仍然可用
    println!("a: {}, b: {}, c: {}, d: {}, e: {:?}", a, b, c, d, e);
}

fn use_copy_types(x: i32, y: f64, z: bool, w: char, t: (i32, i32)) {
    println!("使用 Copy 类型: {}, {}, {}, {}, {:?}", x, y, z, w, t);
}

没有实现 Copy trait 的类型（会被移动）：​

fn main() {
    // 这些类型没有实现 Copy trait，传递给函数时会被移动
    let s = String::from("hello");     // String
    let v = vec![1, 2, 3];            // Vec<i32>
    let b = Box::new(5);              // Box<i32>

    use_non_copy_types(s, v, b);

    // 这些变量都不能再使用了
    // println!("{}", s);  // ❌ 错误
    // println!("{:?}", v); // ❌ 错误
    // println!("{}", b);   // ❌ 错误
}

fn use_non_copy_types(string: String, vector: Vec<i32>, boxed: Box<i32>) {
    println!("使用非 Copy 类型: {}, {:?}, {}", string, vector, boxed);
}

可变性与所有权的关系​

可变性（mut）和所有权是两个独立的概念：

fn main() {
    // 不可变的非 Copy 类型 - 会被移动
    let immutable_string = String::from("hello");
    takes_string(immutable_string);
    // immutable_string 不能再使用

    // 可变的非 Copy 类型 - 也会被移动
    let mut mutable_string = String::from("world");
    takes_string(mutable_string);
    // mutable_string 也不能再使用

    // 不可变的 Copy 类型 - 会被复制
    let immutable_int = 42;
    takes_int(immutable_int);
    println!("{}", immutable_int);  // 仍然可用

    // 可变的 Copy 类型 - 也会被复制
    let mut mutable_int = 100;
    takes_int(mutable_int);
    println!("{}", mutable_int);    // 仍然可用
}

fn takes_string(s: String) { println!("{}", s); }
fn takes_int(n: i32) { println!("{}", n); }

如何避免移动？使用引用​

如果你想在函数调用后继续使用非 Copy 类型，应该传递引用：

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

    // 传递引用，不会移动所有权
    uses_string_ref(&s);

    // s 仍然可用
    println!("s 仍然可用: {}", s);
}

fn uses_string_ref(s: &String) {  // 或者 s: &str
    println!("借用字符串: {}", s);
}

返回值与作用域​

返回值也可以转移所有权：

fn main() {
    let s1 = gives_ownership();         // gives_ownership 将返回值
                                        // 转移给 s1

    let s2 = String::from("hello");     // s2 进入作用域

    let s3 = takes_and_gives_back(s2);  // s2 被移动到
                                        // takes_and_gives_back 中,
                                        // 它也将返回值移给 s3
} // 这里, s3 移出作用域并被丢弃。s2 也移出作用域，但已被移走，
  // 所以什么也不会发生。s1 离开作用域并被丢弃

fn gives_ownership() -> String {             // gives_ownership 会将
                                             // 返回值移动给
                                             // 调用它的函数

    let some_string = String::from("yours"); // some_string 进入作用域

    some_string                              // 返回 some_string 
                                             // 并移出给调用的函数
}

// takes_and_gives_back 将传入字符串并返回该值
fn takes_and_gives_back(a_string: String) -> String { // a_string 进入作用域

    a_string  // 返回 a_string 并移出给调用的函数
}

使用元组返回多个值​

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

    let (s2, len) = calculate_length(s1);

    println!("The length of '{}' is {}.", s2, len);
}

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len(); // len() 返回字符串的长度

    (s, length)
}

但是这未免有些形式主义，而且这种场景应该很常见。幸运的是，Rust 对此提供了一个不用获取所有权就可以使用值的功能，叫做引用（references）。

总结​

所有权系统是 Rust 的核心特性，它确保了内存安全而无需垃圾回收器。理解所有权的关键点：

  1. 每个值都有一个所有者
  2. 同一时间只能有一个所有者
  3. 所有者离开作用域时，值被丢弃
  4. 移动语义防止悬垂指针
  5. Copy trait 允许栈上数据的简单复制

在下一节中，我们将学习引用和借用，这让我们可以使用值而不获取其所有权。