所有权与函数参数
核心概念
在 Rust 中,函数参数的传递方式和所有权紧密相关。当你把一个非 Copy 类型的值传给函数时,所有权会转移到函数内部,调用者就不能再使用这个值了。这个行为和变量赋值一样——函数调用本质上就是把值"赋值"给参数变量。
所有权转移(Move 传参)
fn take_ownership(s: String) {
// s 获得了字符串的所有权
println!("函数内部: {}", s);
// 函数结束时 s 被销毁,字符串内存被释放
}
fn take_vec(v: Vec<i32>) {
println!("向量长度: {}", v.len());
// v 在这里被销毁
}
fn main() {
let s = String::from("hello");
take_ownership(s);
// s 的所有权已经转移到函数参数中
// println!("{}", s); // 编译错误:value borrowed here after move
let v = vec![1, 2, 3];
take_vec(v);
// println!("{:?}", v); // 编译错误:v 已被移动
}Copy 类型传参
实现了 Copy 的类型传参时是复制而不是移动,调用后原变量仍然有效。
fn print_number(n: i32) {
// n 是 i32 的副本,不是原始变量
println!("数字: {}", n);
}
fn print_bool(b: bool) {
println!("布尔值: {}", b);
}
fn main() {
let x = 42;
print_number(x);
println!("x 仍然有效: {}", x); // Copy 类型,x 没有被移动
let flag = true;
print_bool(flag);
println!("flag 仍然有效: {}", flag);
}三种参数传递方式
Rust 函数参数有三种传递方式,分别对应不同的所有权关系。
| 参数形式 | 所有权 | 调用者还能用吗? | 函数能修改吗? |
|---|---|---|---|
value: T | 获取所有权 | 不能(非 Copy) | 能(如果声明 mut) |
ref: &T | 不可变借用 | 能 | 不能 |
ref_mut: &mut T | 可变借用 | 能(借用结束后) | 能 |
// 获取所有权:函数拥有数据
fn consume(s: String) {
println!("消费: {}", s);
}
// 不可变借用:只读访问
fn inspect(s: &String) {
println!("查看: {}", s);
}
// 可变借用:可以修改
fn modify(s: &mut String) {
s.push_str(" modified");
println!("修改: {}", s);
}
fn main() {
let mut s = String::from("data");
// 不可变借用:s 不变
inspect(&s);
println!("inspect 后 s = {}", s);
// 可变借用:s 被修改
modify(&mut s);
println!("modify 后 s = {}", s);
// 获取所有权:s 不再可用
consume(s);
// println!("{}", s); // 编译错误
}什么时候该用哪种
struct Report {
title: String,
data: Vec<f64>,
}
impl Report {
fn new(title: &str, data: Vec<f64>) -> Self {
Report {
title: title.to_string(),
data,
}
}
}
// 只需要读取 → 用不可变引用 &T
fn print_report(report: &Report) {
println!("报告: {}", report.title);
println!("数据: {:?}", report.data);
}
// 需要修改 → 用可变引用 &mut T
fn add_data(report: &mut Report, value: f64) {
report.data.push(value);
}
// 需要消耗或转移 → 用值传递 T
fn archive(report: Report) -> String {
// report 被消耗,资源被转移
let summary = format!("已归档: {} ({} 条数据)", report.title, report.data.len());
// report 在函数结束时被销毁
summary
}
fn main() {
let mut report = Report::new("月度统计", vec![1.0, 2.5, 3.7]);
// 多次读取
print_report(&report);
print_report(&report);
// 修改
add_data(&mut report, 4.2);
add_data(&mut report, 5.1);
print_report(&report);
// 归档(消耗 report)
let result = archive(report);
println!("{}", result);
// report 不再可用
}实际模式对比
// 模式一:传值 + 返回(所有权转移再归还)
fn process_and_return(mut s: String) -> String {
s.push_str("_processed");
s // 返回所有权
}
// 模式二:传可变引用(就地修改)
fn process_in_place(s: &mut String) {
s.push_str("_processed");
}
// 模式三:传不可变引用 + 返回新值(不影响原数据)
fn process_copy(s: &str) -> String {
format!("{}_processed", s)
}
fn main() {
// 模式一
let s1 = String::from("data1");
let s1 = process_and_return(s1); // 所有权转移后归还
println!("模式一: {}", s1);
// 模式二
let mut s2 = String::from("data2");
process_in_place(&mut s2); // 就地修改
println!("模式二: {}", s2);
// 模式三
let s3 = String::from("data3");
let s3_new = process_copy(&s3); // 原数据不变,返回新值
println!("模式三: 原={}, 新={}", s3, s3_new);
}基本示例
用不同的参数传递方式实现一个购物车:
struct Item {
name: String,
price: f64,
}
struct Cart {
items: Vec<Item>,
}
impl Cart {
fn new() -> Cart {
Cart { items: Vec::new() }
}
// 接收 Item 的所有权(物品被放入购物车)
fn add_item(&mut self, item: Item) {
println!("添加: {} (¥{:.2})", item.name, item.price);
self.items.push(item);
}
// 不可变引用:计算总价不需要修改
fn total(&self) -> f64 {
self.items.iter().map(|item| item.price).sum()
}
// 不可变引用:显示购物车内容
fn display(&self) {
println!("\n=== 购物车 ===");
for item in &self.items {
println!(" {} - ¥{:.2}", item.name, item.price);
}
println!(" 合计: ¥{:.2}", self.total());
}
// 可变引用:移除指定物品
fn remove_by_name(&mut self, name: &str) -> Option<Item> {
if let Some(pos) = self.items.iter().position(|i| i.name == name) {
Some(self.items.remove(pos)) // 物品的所有权被移出
} else {
None
}
}
// 消耗购物车:结算后购物车不再可用
fn checkout(self) -> f64 {
let total = self.total();
println!("\n结算完成,共 {} 件商品,总计 ¥{:.2}", self.items.len(), total);
// self 在这里被销毁,所有 Item 被释放
total
}
}
fn main() {
let mut cart = Cart::new();
// 创建物品并转移所有权到购物车
let apple = Item { name: String::from("苹果"), price: 5.5 };
let book = Item { name: String::from("Rust 教程"), price: 89.0 };
let pen = Item { name: String::from("钢笔"), price: 15.0 };
cart.add_item(apple); // apple 所有权转移
cart.add_item(book); // book 所有权转移
cart.add_item(pen); // pen 所有权转移
// apple, book, pen 不再可用
cart.display();
// 移除物品(所有权从购物车转移出来)
if let Some(removed) = cart.remove_by_name("钢笔") {
println!("\n移除了: {} (¥{:.2})", removed.name, removed.price);
}
cart.display();
// 结算(消耗购物车)
let total = cart.checkout();
println!("支付: ¥{:.2}", total);
// cart 不再可用
}常见问题
问题一:为什么 Rust 不默认传引用?
显式的所有权转移让代码的资源管理意图更清晰。当函数参数是 T(值类型)时,函数获取数据的所有权,调用者放弃所有权——资源的流向一目了然。如果默认传引用,就不容易看出谁负责释放资源。
问题二:函数接收 &str 还是 &String?
优先用 &str。&String 可以自动转为 &str(Deref coercion),但反过来不行。用 &str 作为参数更通用,既能接受 String 的引用,也能接受字符串字面量。
问题三:什么时候函数应该获取所有权?
当函数需要长期持有数据(如存入结构体)、需要消耗数据(如发送到另一个线程)、或者是构造函数时,应该获取所有权。只是读取数据就用 &T,需要修改就用 &mut T。
问题四:能不能在传参后把所有权拿回来?
可以让函数返回值来归还所有权,但这种模式比较笨拙。更好的做法是一开始就传引用而不是传值。
适用场景
- 值传递:构造函数、构建器模式、消耗型操作(如发送消息、归档)
- 不可变引用:只读操作、打印、计算、查询
- 可变引用:就地修改、添加/删除元素、更新状态
注意事项
- 非 Copy 类型传值会转移所有权,调用后原变量不可用
- Copy 类型传值会复制,原变量仍然有效
- 优先传引用(
&T或&mut T),除非函数确实需要拥有数据 - 字符串参数优先用
&str而不是&String - 切片参数优先用
&[T]而不是&Vec<T> - 函数签名中的参数类型就是 API 设计的一部分,表达了所有权意图
总结
函数参数的传递方式决定了所有权的流向。值传递(T)转移所有权,函数拥有数据;不可变引用(&T)只借用数据用于读取;可变引用(&mut T)借用数据用于修改。Copy 类型传值时自动复制,不影响原变量。选择哪种方式取决于函数的意图:只读取用 &T,需要修改用 &mut T,需要拥有或消耗用 T。函数参数的类型就是 API 的设计决策,它向调用者传达了"这个函数会怎样使用你的数据"。