Rust所有权机制详解 - 摩柯技术社区

Rust 所有权机制概述

在 Rust 编程中，所有权（Ownership）是其核心特性之一，它是一种管理内存的有效方式，同时也是 Rust 区别于其他语言如 C++、Java 的关键所在。与 C++ 通过手动内存管理或者 Java 借助垃圾回收机制不同，Rust 的所有权系统在编译时就对内存进行了严格的管理，确保内存安全，防止诸如空指针引用、悬空指针以及内存泄漏等常见的内存相关错误。

所有权规则

每个值都有一个变量，这个变量被称为该值的所有者：例如：

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

这里 s 就是字符串 hello 的所有者。 2. 一个值在同一时刻只能有一个所有者：假如我们尝试这样做：

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

在这之后，s1 就不再能使用了，因为所有权已经转移给了 s2。如果尝试使用 s1，编译器会报错。这是因为 Rust 确保了一个值在同一时刻只有一个所有者，避免了多个变量同时试图修改或释放同一内存区域的问题。 3. 当所有者（变量）离开作用域，这个值将被丢弃：例如：

{
    let s = String::from("world");
} // 这里 s 离开了作用域，字符串 "world" 所占用的内存被释放

这里 s 在花括号结束时离开作用域，与之关联的字符串值所占用的堆内存就会被 Rust 自动释放。

栈与堆

为了更好地理解所有权，需要了解 Rust 中栈（Stack）和堆（Heap）的概念。栈是一种后进先出（LIFO）的数据结构，存储的数据大小在编译时是已知的。例如，基本数据类型 i32、bool 等存储在栈上。而堆则用于存储大小在编译时未知的数据，比如 String 类型的数据。

当声明一个 i32 变量：

let num: i32 = 42;

num 的值直接存储在栈上。但是对于 String 类型：

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

String 类型的数据存储在堆上，栈上只存储一个指向堆上数据的指针以及数据的长度和容量信息。

所有权与 String 类型

String 类型是 Rust 中用于表示可变、UTF - 8 编码字符串的类型。与固定大小的字符串字面量（如 "hello"）不同，String 类型的数据存储在堆上，其大小在运行时才确定。

当创建一个 String：

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

String 在堆上分配内存来存储 "hello" 字符串，并在栈上存储指向堆内存的指针、字符串长度以及容量信息。

当进行赋值操作：

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

这里发生了所有权转移。s1 对堆上字符串数据的所有权转移给了 s2。此时 s1 不再是合法的变量，如果尝试使用 s1，编译器会报错：

let s1 = String::from("hello");
let s2 = s1;
println!("{}", s1); // 编译错误：use of moved value: `s1`

这是因为 s1 的值已经被移动到 s2，s1 不再拥有堆上的数据。

拷贝语义与移动语义

拷贝语义（Copy Semantic）：对于存储在栈上的基本数据类型，如 i32、f64、char 等，当进行赋值操作时，发生的是拷贝语义。例如：

let num1: i32 = 42;
let num2 = num1;
println!("num1: {}, num2: {}", num1, num2);

这里 num1 的值被拷贝到 num2，num1 仍然可以使用。这是因为这些基本数据类型实现了 Copy trait。如果一个类型实现了 Copy trait，那么当它被赋值或者作为函数参数传递时，会进行值的拷贝，而不是所有权的转移。 2. 移动语义（Move Semantic）：对于像 String 这样存储在堆上的数据类型，当进行赋值操作时，发生的是移动语义，即所有权的转移。这是为了避免不必要的内存拷贝，提高效率。如前文所述，当 s2 = s1 时，s1 的所有权转移给 s2，s1 不再可用。

函数中的所有权

参数传递：当把一个值传递给函数时，所有权的规则同样适用。例如：

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
}

let s = String::from("hello");
takes_ownership(s);
println!("{}", s); // 编译错误：use of moved value: `s`

这里 s 的所有权被传递给了 takes_ownership 函数，函数结束后，s 所指向的堆内存会被释放。如果在函数调用后尝试使用 s，编译器会报错。 2. 返回值：函数返回值也会涉及所有权的转移。例如：

fn gives_ownership() -> String {
    let some_string = String::from("hello");
    some_string
}

let s = gives_ownership();

这里 gives_ownership 函数创建了一个 String 并将其所有权返回给调用者。调用者通过 let s = gives_ownership() 接收了这个所有权。

引用与借用

虽然所有权机制可以有效地管理内存，但有时我们希望在不转移所有权的情况下访问数据。这时就需要用到引用（Reference）和借用（Borrowing）。

不可变引用：使用 & 符号创建不可变引用。例如：

fn print_length(s: &String) {
    println!("The length of '{}' is {}", s, s.len());
}

let s = String::from("hello");
print_length(&s);
println!("s is still valid: {}", s);

这里 print_length 函数接受一个 String 的不可变引用 &String。通过不可变引用，函数可以读取 String 的内容，但不会获得所有权。因此，在函数调用后，s 仍然是有效的。 2. 可变引用：使用 &mut 符号创建可变引用。例如：

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

let mut s = String::from("hello");
change(&mut s);
println!("s after change: {}", s);

这里 change 函数接受一个 String 的可变引用 &mut String。通过可变引用，函数可以修改 String 的内容。注意，s 必须声明为 mut，并且在同一时刻，只能有一个可变引用指向数据，以避免数据竞争。例如：

let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s; // 编译错误：cannot borrow `s` as mutable more than once at a time

这是 Rust 为了确保内存安全而做出的限制，在编译时就能发现潜在的数据竞争问题。

引用的生命周期

生命周期标注：在 Rust 中，每个引用都有一个生命周期（Lifetime），即引用保持有效的作用域。有时，编译器需要明确知道引用的生命周期关系，这时就需要进行生命周期标注。例如：

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

这里的 'a 就是生命周期参数，它表示 x、y 和返回值的生命周期是相同的。通过这种标注，编译器可以检查引用的生命周期是否合理，确保在引用使用期间，所引用的数据仍然有效。 2. 生命周期省略规则：在很多情况下，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[..]
}

这里编译器可以自动推断出输入引用 s 和返回引用的生命周期关系，尽管没有显式标注。

结构体中的所有权与引用

结构体包含所有权类型：当结构体包含像 String 这样拥有所有权的数据类型时，结构体的所有权规则与普通变量类似。例如：

struct User {
    username: String,
    email: String,
}

let user1 = User {
    username: String::from("rustacean"),
    email: String::from("rustacean@example.com"),
};

这里 user1 拥有 username 和 email 的所有权。当 user1 离开作用域时，username 和 email 所占用的堆内存会被释放。 2. 结构体包含引用类型：结构体也可以包含引用类型，但需要注意引用的生命周期。例如：

struct User<'a> {
    username: &'a str,
    email: &'a str,
}

let name = "rustacean";
let email = "rustacean@example.com";
let user2 = User { username: name, email: email };

这里 User 结构体包含两个不可变引用，'a 表示这两个引用的生命周期相同。通过这种方式，确保在 user2 有效的期间，所引用的数据也是有效的。

所有权与迭代器

迭代器与所有权转移：在 Rust 中，一些迭代器会消耗所迭代的集合的所有权。例如，into_iter 方法会将集合的所有权转移给迭代器。例如：

let v = vec![1, 2, 3];
let mut iter = v.into_iter();
let first = iter.next();

这里 v 的所有权被转移给了 iter。在迭代结束后，v 不再可用。 2. 借用迭代器：还有一些迭代器，如 iter 和 iter_mut，不会转移所有权，而是借用集合。例如：

let v = vec![1, 2, 3];
let mut iter = v.iter();
let first = iter.next();

这里 iter 借用了 v，v 的所有权仍然属于原来的变量，在迭代结束后，v 仍然可以使用。

所有权与错误处理

在错误处理中，所有权也扮演着重要的角色。例如，当函数返回 Result 类型时，其中包含的 Ok 或 Err 值可能涉及所有权的转移。

fn read_username_from_file() -> Result<String, io::Error> {
    let mut file = File::open("username.txt")?;
    let mut s = String::new();
    file.read_to_string(&mut s)?;
    Ok(s)
}

这里如果 File::open 或者 read_to_string 操作失败，函数会返回 Err，其中包含 io::Error。如果操作成功，函数会返回 Ok，其中包含从文件读取的 String，String 的所有权被返回给调用者。

所有权与线程

在多线程编程中，所有权机制可以确保线程安全。例如，std::thread::spawn 函数接受一个闭包，闭包可以捕获环境中的变量。如果捕获的变量是所有权类型，那么所有权会被转移到新线程中。

use std::thread;

let s = String::from("hello");
let handle = thread::spawn(move || {
    println!("{}", s);
});
handle.join().unwrap();

这里通过 move 关键字，s 的所有权被转移到新线程中。这确保了不同线程不会同时访问和修改同一数据，避免了数据竞争和内存安全问题。

通过深入理解 Rust 的所有权机制，开发者可以编写出高效、安全的 Rust 程序，充分发挥 Rust 在内存管理和并发编程方面的优势。在实际编程中，需要根据具体需求，合理运用所有权、引用和生命周期等概念，以实现既高效又可靠的代码。