所有权与返回值 ​

核心概念 ​

函数的返回值同样涉及所有权的转移。当函数返回一个值时,这个值的所有权从函数内部转移给调用者。这意味着函数内部创建的数据不会在函数结束时被销毁,而是"活着"被传递出去。

rust
fn create_string() -> String {
    let s = String::from("hello");
    s  // 所有权从 s 转移给调用者
    // s 本身不再有效,但数据没有被销毁
}

fn main() {
    let result = create_string();
    // result 现在拥有 "hello" 的所有权
    println!("{}", result);
}

返回值转移所有权 ​

rust
// 函数内部创建值并返回所有权
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);
}

接收所有权再返回 ​

函数可以接收一个值的所有权,处理后再把所有权通过返回值还给调用者。

rust
// 接收所有权 → 处理 → 返回所有权
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);
}

返回多个值的所有权 ​

用元组可以同时返回多个值的所有权。

rust
// 返回多个所有权
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);
}

返回引用的限制 ​

函数不能返回指向局部变量的引用——因为局部变量在函数结束时被销毁,引用会变成悬垂引用。

rust
// 编译错误示例:
// 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 传引用 ​

当函数只需要读取或修改数据时,传引用比"传值再返回"更简洁。

rust
// 方式一:传值再返回(笨拙)
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);
}
方式参数返回值原变量可用?适用场景
传值再返回TT需要重新绑定所有权转换链
传不可变引用&T新值可用只读处理
传可变引用&mut T无需返回可用(已修改)就地修改

基本示例 ​

用返回值所有权实现一个构建器模式:

rust
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 引用或输入参数的引用。在不需要转移所有权的场景下,传引用比"传值再返回"更简洁直观。编译器会对返回值进行优化,通常不会产生额外的性能开销。