编辑“︁Rust内存管理”︁

{{DISPLAYTITLE:Rust内存管理}}  
{{编程概念导航}}  

== 概述 ==  
'''Rust内存管理'''是Rust语言的核心特性之一，通过'''所有权系统'''（Ownership System）在编译时静态检查内存安全，避免了垃圾回收（GC）或手动内存管理的复杂性。其核心目标是：  
* 确保内存安全（无悬垂指针、数据竞争等）  
* 零运行时开销（无需垃圾回收）  
* 明确的资源生命周期管理  

Rust通过以下机制实现这一目标：  
* **所有权规则**：每个值有唯一的所有者，所有者离开作用域时值被自动释放。  
* **借用与引用**：允许临时访问数据而不转移所有权。  
* **生命周期**：显式或隐式标注引用的有效范围。  

== 所有权系统基础 ==  
=== 所有权规则 ===  
Rust的所有权规则可总结为：  
1. 每个值有且只有一个所有者（变量）。  
2. 当所有者离开作用域，值被自动释放（调用`drop`）。  
3. 所有权可通过移动（Move）转移，而非默认的浅拷贝。  

<syntaxhighlight lang="rust">  
// 示例1：所有权转移  
fn main() {  
    let s1 = String::from("hello");  
    let s2 = s1; // 所有权从s1移动到s2  
    // println!("{}", s1); // 编译错误！s1不再有效  
    println!("{}", s2); // 输出: hello  
}  
</syntaxhighlight>  

=== 作用域与释放 ===  
变量的生命周期与其作用域绑定：  
<syntaxhighlight lang="rust">  
{  
    let s = String::from("scope");  
    // s在此作用域内有效  
} // 此处s离开作用域，内存自动释放  
</syntaxhighlight>  

== 借用与引用 ==  
为避免频繁所有权转移，Rust引入'''借用'''（Borrowing）机制：  
* **不可变引用**（`&T`）：允许多个只读访问。  
* **可变引用**（`&mut T`）：允许唯一可修改访问，且与不可变引用互斥。  

<syntaxhighlight lang="rust">  
// 示例2：借用规则  
fn calculate_length(s: &String) -> usize {  
    s.len()  
}  

fn main() {  
    let s = String::from("borrow");  
    let len = calculate_length(&s); // 传递不可变引用  
    println!("Length: {}", len); // 输出: Length: 6  
}  
</syntaxhighlight>  

=== 引用规则 ===  
1. 任意时刻，**要么**只能有一个可变引用，**要么**有多个不可变引用。  
2. 引用必须始终有效（无悬垂引用）。  

== 生命周期 ==  
生命周期（Lifetime）是Rust确保引用安全的工具，标注引用的有效范围。编译器通常能自动推断，但复杂场景需显式标注：  

<syntaxhighlight lang="rust">  
// 示例3：显式生命周期标注  
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {  
    if x.len() > y.len() { x } else { y }  
}  

fn main() {  
    let s1 = "abcd";  
    let s2 = "xyz";  
    let result = longest(s1, s2);  
    println!("Longest: {}", result); // 输出: Longest: abcd  
}  
</syntaxhighlight>  

== 实际应用案例 ==  
=== 避免数据竞争 ===  
Rust的所有权系统在并发编程中防止数据竞争：  
<syntaxhighlight lang="rust">  
use std::thread;  

fn main() {  
    let mut data = vec![1, 2, 3];  
    // 编译错误！不能同时存在可变和不可变引用  
    // let ref1 = &data;  
    // let ref2 = &mut data;  
    thread::spawn(move || {  
        data.push(4); // 所有权移动到线程  
    }).join().unwrap();  
}  
</syntaxhighlight>  

=== 资源管理 ===  
所有权模型适用于文件、网络连接等资源管理：  
<syntaxhighlight lang="rust">  
use std::fs::File;  

fn read_file() -> Result<String, std::io::Error> {  
    let mut file = File::open("example.txt")?;  
    let mut contents = String::new();  
    file.read_to_string(&mut contents)?;  
    Ok(contents) // file在函数结束时自动关闭  
}  
</syntaxhighlight>  

== 内存布局图解 ==  
<mermaid>  
graph LR  
    A[栈 Stack] -->|存储固定大小数据| B(变量)  
    C[堆 Heap] -->|存储动态大小数据| D(String/Vec等)  
    B -->|指针指向| D  
    D -->|所有权释放| E[内存回收]  
</mermaid>  

== 常见问题 ==  
=== 为何需要所有权？ ===  
传统语言的问题：  
* C/C++：手动管理易出错（内存泄漏、悬垂指针）。  
* GC语言（如Java）：运行时开销不可预测。  

Rust的解决方案：  
* 编译时检查，零运行时成本。  

=== 所有权与性能 ===  
所有权转移是廉价的（仅复制指针元数据），深拷贝需显式调用`clone()`：  
<syntaxhighlight lang="rust">  
let s1 = String::from("deep");  
let s2 = s1.clone(); // 显式深拷贝  
</syntaxhighlight>  

== 进阶话题 ==  
* **智能指针**：如`Box<T>`、`Rc<T>`、`Arc<T>`，扩展所有权语义。  
* **内部可变性**：通过`RefCell<T>`在运行时检查借用规则。  

{{编程概念小结}}  
Rust的内存管理通过所有权系统实现了安全与效率的平衡，是其区别于其他语言的核心特性。掌握这一概念是编写高效、安全Rust代码的关键。

[[Category:编程语言]]
[[Category:Rust]]
[[Category:Rust所有权系统]]