🦀 Rust 函数参数与返回值中的所有权#

目录#

函数参数的所有权规则
堆数据的移动（Move）
克隆（Clone）
引用（Borrowing）
函数返回值的所有权
综合示例
总结

1️⃣ 函数参数的所有权规则#

Rust 函数传参默认会 转移（Move）所有权：

1
fn take_ownership(s: String) {
2
    println!("我拥有: {}", s);
3
} // s 离开作用域，自动释放堆内存
4

5
fn main() {
6
    let s = String::from("Rust");
7
    take_ownership(s);
8
    // println!("{}", s); // ❌ s 已被移动
9
}

栈类型（如 i32）传参时会拷贝，不影响原变量：

1
fn add_one(x: i32) -> i32 { x + 1 }
2

3
fn main() {
4
    let a = 5;
5
    let b = add_one(a);
6
    println!("a = {}, b = {}", a, b); // a 仍然可用
7
}

2️⃣ 堆数据的移动（Move）#

传递堆数据（String, Vec 等）时默认发生移动：

1
fn append_world(s: String) -> String {
2
    let mut s = s;
3
    s.push_str(" world");
4
    s
5
}
6

7
fn main() {
8
    let s1 = String::from("Hello");
9
    let s2 = append_world(s1); // s1 移动到函数
10
    // println!("{}", s1); // ❌ s1 已失效
11
    println!("{}", s2); // Hello world
12
}

注意：如果函数不返回值，堆内存会在函数结束时被释放。

3️⃣ 克隆（Clone）传参#

如果想保留原变量，可 显式克隆：

1
fn append_exclamation(mut s: String) -> String {
2
    s.push('!');
3
    s
4
}
5

6
fn main() {
7
    let s1 = String::from("Hi");
8
    let s2 = append_exclamation(s1.clone()); // 克隆一份
9
    println!("s1 = {}, s2 = {}", s1, s2);
10
}

输出：

1
s1 = Hi, s2 = Hi!

4️⃣ 引用（Borrowing）#

可以通过引用借用堆数据，不移动所有权：

1
fn print_length(s: &String) {
2
    println!("长度是 {}", s.len());
3
}
4

5
fn main() {
6
    let s = String::from("Rustacean");
7
    print_length(&s); // 借用，不转移所有权
8
    println!("原字符串依然可用: {}", s);
9
}

可变引用允许函数修改数据：

1
fn add_suffix(s: &mut String) {
2
    s.push_str("!!!");
3
}
4

5
fn main() {
6
    let mut s = String::from("Hello");
7
    add_suffix(&mut s);
8
    println!("{}", s); // Hello!!!
9
}

⚠️ 注意：同一时间不能有多个可变引用。

5️⃣ 函数返回值的所有权#

函数可以 返回堆数据，将所有权传给调用者：

1
fn give_ownership() -> String {
2
    let s = String::from("Ownership");
3
    s // 返回所有权
4
}
5

6
fn main() {
7
    let s1 = give_ownership(); // s1 获得所有权
8
    println!("{}", s1);
9
}

返回引用（Borrowing）需谨慎#

1
fn invalid_ref() -> &String {
2
    let s = String::from("Hi");
3
    &s // ❌ 编译错误，s 会在函数结束释放
4
}

函数返回引用必须保证引用有效（通常返回参数引用或全局数据）。

6️⃣ 综合示例#

1
fn main() {
2
    let mut s = String::from("Hello");
3

4
    // 借用不可变引用
5
    print_length(&s);
6

7
    // 借用可变引用
8
    add_suffix(&mut s);
9

10
    // 移动到函数并返回
11
    let s2 = append_world(s);
12
    println!("{}", s2);
13

14
    // 克隆保留原数据
15
    let s3 = append_exclamation(s2.clone());
16
    println!("s2 = {}, s3 = {}", s2, s3);
17
}
18

19
// 函数定义
20
fn print_length(s: &String) { println!("长度: {}", s.len()); }
21
fn add_suffix(s: &mut String) { s.push_str("!!!"); }
22
fn append_world(s: String) -> String {
23
    let mut s = s;
24
    s.push_str(" world");
25
    s
26
}
27
fn append_exclamation(mut s: String) -> String { s.push('!'); s }