首页
/ 正文

Rust 所有权（长文讲解）

更新时间: 2025-04-16 09:56:04

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;

《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前，星球内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习，欢迎点击围观

前言

在编程语言的世界中，内存管理一直是一个既重要又复杂的议题。C/C++ 的手动内存管理需要开发者自行处理，稍有不慎就会引发内存泄漏或野指针等问题；而 Java、Python 等语言虽然通过垃圾回收（GC）机制简化了操作，但依然存在性能损耗和不确定性。Rust 语言则通过其独特的 “所有权”（Ownership） 机制，以编译时检查的方式，在不牺牲性能的前提下实现了内存安全。

本文将从基础概念到实际应用，逐步解析 Rust 所有权的核心原理，并通过代码示例帮助读者理解如何在项目中运用这一机制。无论你是编程新手，还是希望深入理解 Rust 内核逻辑的开发者，都能在本文中找到有价值的内容。

所有权的基本概念：资源归属与转移

1. 所有权的定义

在 Rust 中，“所有权” 是指某个变量对内存资源（如堆内存）的独占控制权。每个值在内存中都有一个所有者（owner），且同一时间只能有一个所有者存在。当所有者离开其作用域（例如函数返回或代码块结束时），该值所占用的内存会被自动释放。

形象比喻：可以将所有权想象成对一本实体书的借阅权。当你从图书馆借书时，你成为这本书的唯一持有者，直到你归还为止。在此期间，其他人无法同时借阅这本书。

2. 所有权的转移：移动语义（Move Semantics）

当一个变量被赋值给另一个变量时，Rust 并不会直接复制值，而是将所有权从原变量转移到新变量。这种机制称为 “移动语义”。

代码示例：

fn main() {  
    let s1 = String::from("Hello");  
    let s2 = s1; // 所有权从 s1 转移到 s2  
    // println!("{}", s1); // 这里会报错，因为 s1 的所有权已被转移  
}

错误提示：

error[E0382]: use of moved value: `s1`  
 --> src/main.rs:4:13  
  |  
3 |     let s2 = s1;  
  |             -- value moved here  
4 |     println!("{}", s1);  
  |             ^^ value used here after move

分析：

s1 是一个堆分配的 String，其所有权在赋值给 s2 时被转移。
此后，s1 不再有效，直接访问会引发编译错误。
这种机制避免了内存资源的重复释放，但可能不符合开发者预期。

3. 所有权的复制：克隆（Clone）

若希望保留原变量的所有权，可以通过 clone() 方法显式复制值。

let s1 = String::from("Hello");  
let s2 = s1.clone(); // 手动克隆，s1 仍有效  
println!("s1 = {}, s2 = {}", s1, s2); // 正常输出

注意事项：

克隆会生成完全独立的副本，代价可能较高（尤其对大对象而言）。
仅在必要时使用，避免性能浪费。

所有权的生命周期：确保资源安全释放

1. 生命周期注解（Lifetime Annotations）

Rust 通过 生命周期注解 确保引用的有效性，避免悬垂指针（dangling pointer）问题。

代码示例：

// 错误案例：未指定生命周期  
fn longest(a: &str, b: &str) -> &str {  
    if a.len() > b.len() {  
        a  
    } else {  
        b  
    }  
}

编译错误：

error[E0106]: missing lifetime specifier  
 --> src/main.rs:1:26  
  |  
1 | fn longest(a: &str, b: &str) -> &str {  
  |                          ^^ expected lifetime parameter

解决方案：
为参数和返回值添加生命周期注解：

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

解析：

'a 表示参数和返回值的生命周期绑定，确保引用不会超出原始数据的存活范围。

2. 生命周期省略规则

在大多数情况下，Rust 编译器能自动推断生命周期，无需显式注解。例如：

// 返回值的生命周期与参数相同  
fn first_char(s: &str) -> &char {  
    &s.chars().next().unwrap()  
}

省略规则：

每个输入引用参数都有一个生命周期参数；
如果只有一个输入生命周期参数，它将被赋予所有输出生命周期；
如果有多个输入参数，且其中一个为 &self 或 &mut self（如结构体方法），则 self 的生命周期被赋予输出。

借用（Borrowing）：临时访问资源

1. 不可变借用与可变借用

Rust 允许通过引用（&）临时借用变量，但遵循以下规则：

不可变借用（&T）：允许多个同时存在，但不能修改数据。
可变借用（&mut T）：同一时间只能有一个存在，且可以修改数据。

代码示例：

let mut num = 10;  
{  
    let ref1 = &num; // 不可变借用  
    let ref2 = &num; // 允许第二个不可变借用  
    // let mut ref_mut = &mut num; // 错误：已有不可变借用存在  
}  
let mut_ref = &mut num; // 离开作用域后可变借用生效

2. 借用检查器（Borrow Checker）

Rust 编译器内置的 “借用检查器” 会静态分析代码，确保所有借用规则被遵守。例如：

fn main() {  
    let mut data = vec![1, 2, 3];  
    let first = &data[0]; // 不可变借用  
    data.push(4); // 错误：修改时存在不可变借用  
    println!("{}", first);  
}

错误提示：

error[E0502]: cannot borrow `data` as mutable because it is also borrowed as immutable  
 --> src/main.rs:4:5  
  |  
3 |     let first = &data[0]; // 不可变借用  
  |                  ----- immutable borrow occurs here  
4 |     data.push(4); // 错误：尝试可变借用  
  |     ^^^^ mutable borrow occurs here  
5 |     println!("{}", first);  
  |                    ----- immutable borrow later used here

解决方法：
确保在修改数据前，所有不可变借用已失效：

let mut data = vec![1, 2, 3];  
{  
    let first = &data[0]; // 局限在代码块内  
    println!("{}", first);  
} // 此处借用结束  
data.push(4); // 现在可以安全修改

所有权在函数中的传递

1. 函数参数的所有权转移

当值传递给函数时，默认会转移所有权。若希望保留所有权，需使用引用（& 或 &mut）。

示例：

fn print_string(s: String) {  
    println!("Received: {}", s);  
}  

fn main() {  
    let s = String::from("Hello");  
    print_string(s); // 所有权转移给函数  
    // println!("{}", s); // 错误：s 已失效  
}

2. 返回值与所有权

函数返回值会将所有权转移给调用方。例如：

fn create_message() -> String {  
    let msg = String::from("Hello, Rust!");  
    msg // 返回 msg 的所有权  
}  

fn main() {  
    let message = create_message();  
    println!("{}", message); // 正常输出  
}

3. 参考与所有权的平衡

在需要同时操作多个变量时，可借助 元组引用 或 结构体：

struct Person {  
    name: String,  
    age: u32,  
}  

fn update_age(p: &mut Person) {  
    p.age += 1; // 通过可变引用修改  
}  

fn main() {  
    let mut person = Person { name: "Alice".into(), age: 30 };  
    update_age(&mut person); // 传递可变引用  
    println!("Age: {}", person.age); // 输出 31  
}

所有权与智能指针：进一步扩展

1. 引用计数（Rc）

当需要 多个所有者 时，可以使用 Rc<T>（仅限单线程环境）。它通过计数器跟踪引用数量，当计数为零时释放资源。

示例：

use std::rc::Rc;  

fn main() {  
    let data = Rc::new(vec![1, 2, 3]);  
    let a = data.clone(); // 增加引用计数  
    let b = data.clone(); // 再次增加  
    // 当 a 和 b 脱离作用域后，数据才会被释放  
}

2. 引用循环问题

Rc<T> 无法处理循环引用（如 A 指向 B，B 指向 A），此时需使用 Weak<T> 进行弱引用。

3. 线程安全的智能指针（Arc）

在多线程场景下，Arc<T> 提供原子引用计数，确保线程安全。

实战案例：构建安全的内存管理

案例 1：避免内存泄漏

假设我们需要动态管理一个字符串列表：

struct StringList {  
    elements: Vec<String>,  
}  

impl StringList {  
    fn new() -> StringList {  
        StringList { elements: Vec::new() }  
    }  

    // 安全添加元素  
    fn push(&mut self, s: String) {  
        self.elements.push(s); // 所有权转移至 Vec  
    }  

    // 安全访问元素  
    fn get(&self, index: usize) -> Option<&str> {  
        self.elements.get(index).map(|s| &**s)  
    }  
}

关键点：

通过 &mut self 确保独占访问。
使用 Vec<String> 自动管理内存，无需手动释放。

案例 2：处理复杂数据结构

考虑一个包含引用的树形结构：

struct Node {  
    value: String,  
    children: Vec<Rc<Node>>, // 使用 Rc 实现多个引用  
}  

impl Node {  
    fn new(value: String) -> Rc<Self> {  
        Rc::new(Node { value, children: Vec::new() })  
    }  

    fn add_child(&mut self, child: Rc<Node>) {  
        self.children.push(child);  
    }  
}  

fn main() {  
    let root = Node::new("Root".to_string());  
    let child = Node::new("Child".to_string());  
    root.add_child(child); // 自动处理引用计数  
}

结论

Rust 的 “所有权” 机制通过编译时检查，将内存安全问题转化为可预测的错误，避免了运行时的不确定性。无论是基础的变量赋值、函数参数传递，还是复杂的引用计数场景，开发者都能通过这一机制实现高效且无隐患的代码编写。

对于初学者而言，理解所有权的核心规则（如移动语义、借用规则）是掌握 Rust 的关键；而中级开发者则可通过智能指针（如 Rc<T>、Arc<T>）和生命周期注解，构建更复杂的应用场景。

随着 Rust 在系统编程、WebAssembly 和嵌入式领域的广泛应用，掌握所有权机制不仅是语言入门的必经之路，更是成为高效、安全开发者的重要基石。

（字数统计：约 1850 字）

Rust 所有权（长文讲解）

前言

所有权的基本概念：资源归属与转移

1. 所有权的定义

2. 所有权的转移：移动语义（Move Semantics）

3. 所有权的复制：克隆（Clone）

所有权的生命周期：确保资源安全释放

1. 生命周期注解（Lifetime Annotations）

2. 生命周期省略规则

借用（Borrowing）：临时访问资源

1. 不可变借用与可变借用

2. 借用检查器（Borrow Checker）

所有权在函数中的传递

1. 函数参数的所有权转移

2. 返回值与所有权

3. 参考与所有权的平衡

所有权与智能指针：进一步扩展

1. 引用计数（Rc）

2. 引用循环问题

3. 线程安全的智能指针（Arc）

实战案例：构建安全的内存管理

案例 1：避免内存泄漏

案例 2：处理复杂数据结构

结论

最新发布

jQuery.each()方法（长文解析）

jQuery.extend()方法（长文解析）

jQuery.fn.extend()方法（千字长文）

jQuery.globalEval()方法（长文讲解）

jQuery.grep() 方法（长文讲解）

jQuery.inArray() 方法（长文讲解）

jQuery.isArray() 方法（手把手讲解）

jQuery.isEmptyObject() 方法（千字长文）

jQuery.isFunction() 方法（建议收藏）

jQuery.isNumeric() 方法（手把手讲解）