当前位置：首页 > ops >正文

Rust 所有权系统：深入浅出指南

ops 2025/7/14 6:35:26

所有权是 Rust 最核心的特性，它使 Rust 能在无需垃圾回收的情况下保证内存安全。下面我将用直观的方式解释所有权系统：

所有权三大原则

每个值都有唯一的所有者
值在所有者离开作用域时被自动释放
同一时间只能有一个可变引用，或多个不可变引用

fn main() {// 所有权示例let s1 = String::from("hello"); // s1 成为所有者let s2 = s1; // 所有权转移给 s2// println!("{}", s1); // 错误！s1 不再拥有数据println!("{}", s2); // 正确
} // s2 离开作用域，内存自动释放

所有权转移（Move）

当变量赋值给另一个变量或作为函数参数传递时，所有权会发生转移：

fn take_ownership(s: String) {println!("函数内: {}", s);
} // s 离开作用域，内存释放fn main() {let s = String::from("hello");take_ownership(s); // 所有权转移到函数// println!("{}", s); // 错误！s 不再有效
}

借用（Borrowing）

为了避免所有权转移，可以使用引用（借用）：

fn calculate_length(s: &String) -> usize {s.len()
} // 不释放内存，因为不拥有所有权fn main() {let s = String::from("hello");let len = calculate_length(&s); // 借用 sprintln!("'{}' 的长度是 {}", s, len); // s 仍然有效
}

引用规则

不可变引用：可以有多个只读引用
可变引用：只能有一个可写引用
互斥规则：不能同时存在可变和不可变引用

fn main() {let mut s = String::from("hello");let r1 = &s; // 不可变引用 OKlet r2 = &s; // 不可变引用 OK// let r3 = &mut s; // 错误！不能同时有不可变和可变引用println!("{}, {}", r1, r2);let r3 = &mut s; // 现在可以创建可变引用r3.push_str(", world");
}

生命周期（Lifetimes）

编译器使用生命周期确保引用始终有效：

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {if x.len() > y.len() { x } else { y }
}fn main() {let s1 = String::from("abcd");let result;{let s2 = String::from("xyz");result = longest(s1.as_str(), s2.as_str());println!("最长的字符串是 {}", result);}// println!("{}", result); // 错误！s2 已离开作用域
}

所有权实践技巧

需要修改数据时使用可变引用：

fn add_prefix(s: &mut String) {s.insert_str(0, "前缀: ");
}

2. 需要返回数据所有权时直接返回值：

fn create_greeting(name: &str) -> String {format!("你好, {}!", name)
}

3. 需要多个返回值时使用元组：

fn split_at(s: String, mid: usize) -> (String, String) {let first = s[..mid].to_string();let second = s[mid..].to_string();(first, second)
}

所有权图解

+---------+      +---------------+
| 所有者  | ---> |   值（数据）   |
+---------+      +---------------+|| 转移所有权v
+---------+      +---------------+
| 新所有者 | ---> |   值（数据）   |
+---------+      +---------------+

常见问题解决

问题： 需要在多个地方使用同一个值
解决方案： 使用 Rc<T>（引用计数智能指针）

use std::rc::Rc;fn main() {let s = Rc::new(String::from("共享数据"));let s1 = Rc::clone(&s);let s2 = Rc::clone(&s);println!("{}, {}, {}", s, s1, s2);
} // 当所有引用计数归零时，内存释放

问题： 需要在多个线程间共享数据
解决方案： 使用 Arc<T>（原子引用计数）

use std::sync::Arc;
use std::thread;fn main() {let s = Arc::new(String::from("多线程共享"));let mut handles = vec![];for _ in 0..3 {let s_clone = Arc::clone(&s);handles.push(thread::spawn(move || {println!("{}", s_clone);}));}for handle in handles {handle.join().unwrap();}
}