Rust开发之函数的定义、参数传递与返回值处理

拥抱太阳的月亮405

1555人浏览 · 2025-11-03 17:53:23

拥抱太阳的月亮405 · 2025-11-03 17:53:23 发布

本文深入讲解 Rust 中函数的基础语法与核心机制，涵盖函数定义、参数传递方式（值传递、借用）、返回值处理以及常见实践模式。通过清晰的代码示例和结构化学习路径，帮助初学者掌握 Rust 函数编程的核心技能，为后续模块化开发打下坚实基础。

一、Rust 函数：程序的基本构建单元

在 Rust 编程语言中，函数（Function）是组织代码逻辑的最基本单位。它允许我们将一段可重复使用的代码封装起来，并通过名称调用执行。Rust 的函数设计强调安全性、性能和清晰性，其语法简洁且功能强大。

与其他系统级语言类似，Rust 程序的入口点是一个名为 main 的特殊函数：

fn main() {
    println!("Hello, world!");
}

但这只是起点。我们可以通过自定义函数来实现更复杂的逻辑拆分与复用。

二、函数的定义语法详解

Rust 使用 fn 关键字来定义函数，基本语法如下：

fn 函数名(参数列表) -> 返回类型 {
    // 函数体
    // 最后一个表达式自动作为返回值
}

✅ 示例：计算两个数之和

fn add(a: i32, b: i32) -> i32 {
    a + b  // 表达式结尾无分号，表示返回该值
}

fn main() {
    let result = add(5, 7);
    println!("5 + 7 = {}", result); // 输出: 5 + 7 = 12
}

🔍 语法要点解析

组成部分	说明
`fn`	声明一个新函数的关键字
`add`	函数名称，遵循蛇形命名法（snake_case）
`(a: i32, b: i32)`	参数列表，每个参数必须显式声明类型
`-> i32`	箭头指定返回类型，此处为 32 位整数
`a + b`	没有分号的表达式，自动作为返回值

⚠️ 注意：如果在表达式末尾加上分号 ;，则会变成语句，不再返回值。例如 a + b; 是一条语句，不会返回结果。

若需显式使用 return 返回，也可写作：

fn add_with_return(a: i32, b: i32) -> i32 {
    return a + b;
}

但这种写法在简单函数中不推荐，Rust 鼓励利用表达式求值自动返回的特性。

三、参数传递机制：值 vs 借用

Rust 的所有权系统深刻影响了函数如何接收参数。主要有三种传参方式：

1. 所有权转移（值传递）

当传递一个拥有所有权的数据类型（如 String、Vec<T>）时，默认会发生 所有权转移。

fn take_ownership(s: String) {
    println!("收到字符串: {}", s);
} // s 在此作用域结束时被丢弃（drop）

fn main() {
    let my_string = String::from("Hello");
    take_ownership(my_string);
    // ❌ 错误！my_string 已经被移动，不能再使用
    // println!("{}", my_string); // 编译错误！
}

✅ 解决方案：使用引用（借用）

2. 不可变借用（&T）

通过 & 符号传递引用，避免所有权转移。

fn borrow_string(s: &String) {
    println!("借用字符串: {}", s);
} // s 是引用，不拥有所有权，不会释放资源

fn main() {
    let my_string = String::from("Hello");
    borrow_string(&my_string); // 传入引用
    println!("main 中仍可使用: {}", my_string); // ✅ 正常运行
}

此时 s 只是对原数据的“只读视图”，无法修改内容。

3. 可变借用（&mut T）

若需要在函数内部修改数据，则使用可变引用。

fn append_world(s: &mut String) {
    s.push_str(" World");
}

fn main() {
    let mut my_string = String::from("Hello");
    append_world(&mut my_string);
    println!("修改后: {}", my_string); // 输出: Hello World
}

📌 重要规则：

同一时刻只能有一个可变借用，或多个不可变借用。
可变借用期间不能存在其他任何引用。

let mut s = String::from("hello");

{
    let r1 = &s; // ✅ 允许
    let r2 = &s; // ✅ 允许（多个不可变引用）
    println!("{} and {}", r1, r2);
} // r1 和 r2 失效

let r3 = &mut s; // ✅ 此时可以获取可变引用
println!("{}", r3);

四、返回值处理与所有权规则

Rust 的函数不仅可以返回基本类型，还能安全地返回复杂类型，关键在于理解所有权的流转。

✅ 返回值的所有权转移

函数返回值会将所有权移出函数作用域。

fn create_greeting() -> String {
    let greeting = String::from("Hi there!");
    greeting // 所有权被转移给调用者
}

fn main() {
    let msg = create_greeting(); // msg 获得所有权
    println!("{}", msg); // ✅ 正常访问
} // msg 在此处被 drop

这正是 Rust 实现零成本抽象的重要机制之一——无需手动管理内存，编译器自动追踪所有权。

🔄 返回引用的风险与生命周期

直接返回局部变量的引用是非法的，因为变量将在函数结束时销毁：

// ❌ 编译错误！不能返回局部变量的引用
fn bad_function() -> &String {
    let s = String::from("oops");
    &s // s 将被释放，引用悬空！
}

要解决此类问题，必须引入生命周期标注（详见后续章节），或者返回拥有所有权的对象。

五、多返回值？使用元组模拟

Rust 不支持传统意义上的“多返回值”，但我们可以通过元组（tuple）实现类似效果。

fn divide_remainder(dividend: i32, divisor: i32) -> (i32, i32) {
    (dividend / divisor, dividend % divisor)
}

fn main() {
    let (quotient, remainder) = divide_remainder(10, 3);
    println!("商: {}, 余数: {}", quotient, remainder); // 商: 3, 余数: 1
}

你也可以选择只解构部分字段：

let result = divide_remainder(15, 4);
let (_, rem) = result;
println!("余数是: {}", rem);

六、实战演示：学生成绩评级函数

下面我们结合前面所学知识，编写一个完整的案例：根据分数判断等级。

功能需求

输入：学生姓名（String）、成绩（u32）
输出：评级字符串（String）
要求：主函数能继续使用原始数据

完整代码实现

// 根据分数返回评级
fn get_grade(score: u32) -> String {
    match score {
        90..=100 => "A".to_string(),
        80..=89 => "B".to_string(),
        70..=79 => "C".to_string(),
        60..=69 => "D".to_string(),
        _ => "F".to_string(),
    }
}

// 打印学生信息（仅借用）
fn print_student_info(name: &str, score: u32, grade: &str) {
    println!("学生: {}, 分数: {}, 等级: {}", name, score, grade);
}

fn main() {
    let student_name = String::from("Alice");
    let student_score = 85;

    // 计算等级（返回新 String）
    let grade = get_grade(student_score);

    // 借用 name 和 grade 进行打印
    print_student_info(&student_name, student_score, &grade);

    // 主函数仍然可以使用所有变量
    println!("评估完成，原始数据未丢失！");
}

🧩 分析与说明

函数	参数类型	返回类型	所有权行为
`get_grade`	`u32`（复制类型）	`String`	返回新所有权
`print_student_info`	`&str`, `u32`, `&str`	`()`（无返回）	仅借用，不获取所有权

💡 提示：&str 是字符串切片，适合用于函数参数，避免不必要的克隆。

七、数据表格：函数参数与返回值对比分析

场景	参数类型	是否转移所有权	是否可修改	适用场景
读取基本类型	`i32`, `bool` 等	否（Copy 类型自动复制）	否	数值计算
读取字符串/向量	`&String`, `&Vec<T>`	否（借用）	否	查看内容
修改复杂数据	`&mut String`, `&mut Vec<T>`	否（借用）	是	更新状态
获取所有权	`String`, `Vec<T>`	是	是（可在函数内自由操作）	数据消费或转换
返回数据	`String`, `Vec<T>`	是（移出函数）	-	构造新对象

✅ 推荐原则：优先使用引用传参（&T 或 &mut T），除非确实需要取得所有权。

八、关键字高亮说明

以下是在本案例中出现的关键 Rust 关键字及其用途：

关键字	高亮颜色建议	用途说明
`fn`	🔵 蓝色	定义函数
`->`	🔴 红色	指定返回类型
`return`	🟡 黄色	显式返回（非必需）
`&`	🟢 绿色	创建不可变引用
`&mut`	🟣 紫色	创建可变引用
`String`	🟠 橙色	动态字符串类型（堆分配）
`&str`	🟠 橙色	字符串切片（栈上引用）
`match`	🔵 蓝色	模式匹配控制流