所有权与函数参数 ​

核心概念 ​

在 Rust 中,函数参数的传递方式和所有权紧密相关。当你把一个非 Copy 类型的值传给函数时,所有权会转移到函数内部,调用者就不能再使用这个值了。这个行为和变量赋值一样——函数调用本质上就是把值"赋值"给参数变量。

所有权转移(Move 传参) ​

rust
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 的类型传参时是复制而不是移动,调用后原变量仍然有效。

rust
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可变借用能(借用结束后)能
rust
// 获取所有权:函数拥有数据
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);  // 编译错误
}

什么时候该用哪种 ​

rust
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 不再可用
}

实际模式对比 ​

rust
// 模式一:传值 + 返回(所有权转移再归还)
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);
}

基本示例 ​

用不同的参数传递方式实现一个购物车:

rust
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 的设计决策,它向调用者传达了"这个函数会怎样使用你的数据"。