所有权与返回值
核心概念
函数的返回值同样涉及所有权的转移。当函数返回一个值时,这个值的所有权从函数内部转移给调用者。这意味着函数内部创建的数据不会在函数结束时被销毁,而是"活着"被传递出去。
fn create_string() -> String {
let s = String::from("hello");
s // 所有权从 s 转移给调用者
// s 本身不再有效,但数据没有被销毁
}
fn main() {
let result = create_string();
// result 现在拥有 "hello" 的所有权
println!("{}", result);
}返回值转移所有权
// 函数内部创建值并返回所有权
fn make_greeting(name: &str) -> String {
// greeting 在函数内部创建
let greeting = format!("你好,{}!", name);
greeting // 所有权转移给调用者
}
// 工厂函数:创建并返回复杂对象
fn create_list(items: &[&str]) -> Vec<String> {
items.iter().map(|&s| s.to_string()).collect()
// Vec 的所有权转移给调用者
}
fn main() {
let msg = make_greeting("张三");
println!("{}", msg);
let list = create_list(&["苹果", "香蕉", "橙子"]);
println!("{:?}", list);
}接收所有权再返回
函数可以接收一个值的所有权,处理后再把所有权通过返回值还给调用者。
// 接收所有权 → 处理 → 返回所有权
fn append_suffix(mut s: String, suffix: &str) -> String {
s.push_str(suffix);
s // 处理后把所有权还回去
}
// 接收 Vec 的所有权,过滤后返回
fn filter_positive(v: Vec<i32>) -> Vec<i32> {
v.into_iter().filter(|&x| x > 0).collect()
}
fn main() {
let s = String::from("hello");
// s 的所有权转入函数,处理后通过返回值拿回来
let s = append_suffix(s, "_world");
println!("{}", s); // "hello_world"
let numbers = vec![-3, 1, -4, 1, 5, -9, 2, 6];
let positives = filter_positive(numbers);
// numbers 已不可用,positives 拥有新的 Vec
println!("正数: {:?}", positives);
}返回多个值的所有权
用元组可以同时返回多个值的所有权。
// 返回多个所有权
fn split_at_space(s: String) -> (String, String) {
if let Some(pos) = s.find(' ') {
let first = s[..pos].to_string();
let rest = s[pos+1..].to_string();
(first, rest)
} else {
(s, String::new())
}
}
// 接收所有权,返回处理结果和原数据
fn process_with_stats(data: Vec<i32>) -> (Vec<i32>, usize, i32) {
let len = data.len();
let sum: i32 = data.iter().sum();
(data, len, sum) // 把 data 的所有权也返回
}
fn main() {
let sentence = String::from("hello world");
let (first, rest) = split_at_space(sentence);
println!("第一个词: '{}', 剩余: '{}'", first, rest);
let nums = vec![1, 2, 3, 4, 5];
let (nums, count, total) = process_with_stats(nums);
// nums 的所有权被归还了
println!("数据: {:?}, 数量: {}, 总和: {}", nums, count, total);
}返回引用的限制
函数不能返回指向局部变量的引用——因为局部变量在函数结束时被销毁,引用会变成悬垂引用。
// 编译错误示例:
// fn dangling_ref() -> &String {
// let s = String::from("hello");
// &s // 错误!s 在函数结束时被销毁,引用会悬垂
// }
// 正确做法一:返回值(所有权转移)
fn return_owned() -> String {
let s = String::from("hello");
s // 所有权转移,数据不会被销毁
}
// 正确做法二:返回 'static 引用
fn return_static_ref() -> &'static str {
"这是静态字符串" // 字面量的生命周期是 'static
}
// 正确做法三:返回输入参数的引用
fn longer<'a>(a: &'a str, b: &'a str) -> &'a str {
if a.len() > b.len() { a } else { b }
}
fn main() {
let s = return_owned();
println!("{}", s);
let r = return_static_ref();
println!("{}", r);
let a = String::from("hello");
let b = String::from("hi");
let result = longer(&a, &b);
println!("更长的: {}", result);
}传值再返回 vs 传引用
当函数只需要读取或修改数据时,传引用比"传值再返回"更简洁。
// 方式一:传值再返回(笨拙)
fn to_uppercase_owned(s: String) -> String {
s.to_uppercase()
}
// 方式二:传引用(推荐)
fn to_uppercase_ref(s: &str) -> String {
s.to_uppercase()
}
// 方式三:可变引用就地修改(无需返回)
fn make_uppercase(s: &mut String) {
*s = s.to_uppercase();
}
fn main() {
// 方式一:需要转移所有权再拿回来
let s1 = String::from("hello");
let s1 = to_uppercase_owned(s1);
println!("方式一: {}", s1);
// 方式二:传引用,原值不受影响
let s2 = String::from("world");
let upper = to_uppercase_ref(&s2);
println!("方式二: 原={}, 新={}", s2, upper);
// 方式三:就地修改
let mut s3 = String::from("rust");
make_uppercase(&mut s3);
println!("方式三: {}", s3);
}| 方式 | 参数 | 返回值 | 原变量可用? | 适用场景 |
|---|---|---|---|---|
| 传值再返回 | T | T | 需要重新绑定 | 所有权转换链 |
| 传不可变引用 | &T | 新值 | 可用 | 只读处理 |
| 传可变引用 | &mut T | 无需返回 | 可用(已修改) | 就地修改 |
基本示例
用返回值所有权实现一个构建器模式:
struct QueryBuilder {
table: String,
conditions: Vec<String>,
order_by: Option<String>,
limit: Option<usize>,
}
impl QueryBuilder {
// 工厂函数:创建并返回所有权
fn new(table: &str) -> QueryBuilder {
QueryBuilder {
table: table.to_string(),
conditions: Vec::new(),
order_by: None,
limit: None,
}
}
// 链式方法:接收 self 所有权,修改后返回所有权
fn where_clause(mut self, condition: &str) -> QueryBuilder {
self.conditions.push(condition.to_string());
self // 返回所有权,支持链式调用
}
fn order(mut self, field: &str) -> QueryBuilder {
self.order_by = Some(field.to_string());
self
}
fn take(mut self, n: usize) -> QueryBuilder {
self.limit = Some(n);
self
}
// 最终消耗 self,生成查询字符串
fn build(self) -> String {
let mut sql = format!("SELECT * FROM {}", self.table);
if !self.conditions.is_empty() {
sql.push_str(" WHERE ");
sql.push_str(&self.conditions.join(" AND "));
}
if let Some(order) = &self.order_by {
sql.push_str(&format!(" ORDER BY {}", order));
}
if let Some(limit) = self.limit {
sql.push_str(&format!(" LIMIT {}", limit));
}
sql
}
}
fn main() {
// 链式调用:每一步都是所有权的转移和返回
let query = QueryBuilder::new("users")
.where_clause("age > 18")
.where_clause("active = true")
.order("name")
.take(10)
.build();
println!("生成的查询: {}", query);
// 分步构建
let builder = QueryBuilder::new("products");
let builder = builder.where_clause("price < 100"); // 所有权转移
let builder = builder.order("price"); // 所有权转移
let sql = builder.build(); // 消耗 builder
println!("生成的查询: {}", sql);
}常见问题
问题一:函数返回值的内存是在哪里分配的?
对于堆数据(如 String、Vec),内存分配在堆上,函数返回时只是把栈上的元数据(指针、长度、容量)复制给调用者,堆上的数据不动。编译器还可能通过返回值优化(RVO)直接在调用者的栈空间构造数据,避免复制。
问题二:返回大型结构体有没有性能问题?
通常没有。Rust 编译器会进行返回值优化,直接在目标位置构造数据。即使没有优化,返回值也只是移动栈上的元数据。真正大型的纯栈数据(如大数组)可以考虑用 Box 包装。
问题三:构建器模式为什么用 self 而不是 &mut self?
用 self 的构建器模式支持链式调用并且在最终 build() 时消耗构建器,防止构建后再次使用。用 &mut self 的构建器不能链式调用(因为返回的是 &mut Self 而不是 Self),但构建后构建器仍然可以复用。
问题四:Option 和 Result 的返回值也涉及所有权吗?
是的。Option<T> 和 Result<T, E> 内部包含值的所有权。返回 Some(value) 或 Ok(value) 就是把 value 的所有权包装在容器中传出去。
适用场景
- 工厂函数:创建并返回新对象
- 构建器模式:链式调用中传递所有权
- 转换函数:接收一个值,转换后返回新值
- 所有权归还:函数临时使用数据后归还调用者
注意事项
- 函数返回值会把所有权转移给调用者
- 不能返回指向局部变量的引用(会悬垂)
- 可以返回
'static引用或输入参数的引用 - 只读操作优先传引用而不是"传值再返回"
- 构建器模式利用返回值所有权实现链式调用
- 编译器通过 RVO 优化返回值,通常没有额外性能开销
- 元组可以一次返回多个值的所有权
总结
函数返回值是所有权转移的另一个重要场景。函数内部创建的值通过返回值把所有权交给调用者,数据不会在函数结束时被销毁。这个机制让工厂函数、构建器模式等设计模式得以实现。函数不能返回指向局部变量的引用(防止悬垂引用),但可以返回拥有所有权的值、'static 引用或输入参数的引用。在不需要转移所有权的场景下,传引用比"传值再返回"更简洁直观。编译器会对返回值进行优化,通常不会产生额外的性能开销。