在任何编程语言中，函数都是最基本的抽象单元。但在 Rust 中，函数定义与参数传递的机制，远不止是语法约定；它们是 Rust 核心价值——内存安全与并发安全——的直接体现。作为一名 Rust 开发者，深入理解这一点，是从“会写”到“精通”的关键一步。

本文将深入探讨 Rust 函数如何通过其参数传递机制，在编译期构建出强大的安全契约。

函数定义：显式与精准精准

Rust 的函数定义语法是清晰的：使用 fn 关键字，参数和返回值都必须显式声明类型。

fn add_one(x: i32) -> i32 {
    x + 1 // 这是一个表达式，作为返回值
}

这表面上看起来平平无奇，但“显式类型”是 Rust 安全承诺的第一个基石。它消除了类型推导可能带来的歧义，并为后续更复杂的泛型和 Trait 约束打下基础。

更重要的是 Rust 对“语句”（Statement）和“表达式”（Expression）的区分。函数体由一系列语句组成，并可以以一个表达式结尾。这个结尾的表达式（无需 return 关键字和分号）将成为函数的返回值。这鼓励了一种“面向表达式”的编程风格，使得函数体更加简洁，逻辑流更清晰。

参数传递的核心：所有权、借用与契约

Rust 的真正深度体现在其参数传递上。它没有“垃圾回收”也没有“空指针”，而是通过一套严格的所有权（Ownership）系统来管理内存。函数参数的传递方式，正是所有权系统在 API 层面上的具象化。

在 Rust 中，传递参数主要有三种方式，每一种都代表了函数对调用者数据的一种“承诺”或“契约”。

1. 转移所有权 (Move / T)

fn process_data(data: String) {
    // 此函数现在“拥有” data
    println!("Processing: {}", data);
    // data 在函数结束时被丢弃 (drop)
}

fn main() {
    let s = String::from("Hello");
    process_data(s);
    // println!("{}", s); // 编译错误！s 的所有权已经转移
}

专业解读：
当参数类型为 T（如 String）时，调用者将失去对该数据的所有权。这是“破坏性”的传递。

实践思考：
这在 API 设计中是一个非常强烈的信号。它告诉调用者：“把这个数据给我，我将负责它的生命周期”。这常见于：

• 构造器模式（Builder Pattern）： `.uild()方法通常会获取self(而不是&self`)，消耗掉 Builder 实例，并返回最终的产品。
• **线程信：** 将数据发送到另一个线程时，所有权必须转移，以防止数据竞争。

<h4>2. 不可变借用 (Immutable Borrow / &T)</h4>

fn inspect_data(data: &String) {
    // 此函数“借用”了 data 的只读权限
    println!("Inspecting: {}", data);
    // data.push_str("!"); // 编译错误！不能修改不可变借用
}

fn main() {
    let s = String::from("Hello");
    inspect_data(&s); // 传递引用
    println!("{}", s); // 正常工作，s 仍归 main 函数所有
}

专业解读：
使用 `&T函数只是“借阅”数据。它承诺不会修改数据。Rust 的借用检查器（Borrow Checker）会强制执行这个承诺：在 inspect_data 活跃的期间，main 函数也不能修改 s（尽管在这里它没有尝试）。

**实践：**
这是最高效、最安全的参数传递方式，因为它避免了数据拷贝（如 i32 这类实现了 Copy Trait 的类型除外，它们按位复制，开销极低）。当你的函数只需要读取数据时，**永远优先使用 `&T它对调用者的侵入性最小。

3. 可变借用 (Mutable Borrow / &mut T)

fn modify_data(data: &mut String) {
    // 此函数“借用”了 data 的独占性写权限
    data.push_str(" World");
}

fn main() {
    let mut s = String::from("Hello"); // s 必须是可变的
    modify_data(&mut s); // 传递可变引用
    println!("{}", s); // 输出 "Hello World"
}

**专业解读：
&mut T 是 Rust 防止数据竞争（Data Races）的核心机制。它是一个“独占性”借用。当函数持有 &mut T 时，Rust 编译器保证在整个借用期间，不存在任何其他对该数据的引用（无论是可变还是不可变）。

实践思考：
这是 C/C++ 开发者最容易出错的地方。在 C++ 中，你可以随意传递多个非 `const 指针指向同一块内存，这极易导致并发修改和迭代器失效。

在 Rust 中，&mut T 的契约是：“我需要修改这份数据，并且我需要保证在我修改期间，没有其他人能读取或写入它。”

这种设计在实践中具有深远意义：

• 杜绝迭代器失效： 当你遍历一个 Vec 并尝试在循环中修改它（获取 &mut Vec）时，编译器会阻止你，因为遍历本身已经（不可变）借用了 Vec。
• 安全的 API： 它迫使开发者思考“谁”在“何时”可以修改数据。如果一个函数需要修改输入，它必须在签名中明确要求 &mut T，调用者也必须显式传递 &mut s。

总结：函数签名即安全文档

在 Rust 中，函数签名不仅是其功能的描述，更是其内存安全行为的文档和契约。

• fn(T)：函数将消耗数据。
• fn(&T)：函数将读取数据。
• fn(&mut T)：函数将（独占性地）修改数据。

这种在编译期强制执行的显式约定，正是 Rust 能够自信地舍弃垃圾回收，并提供“无畏并发”（Fearless Concurrency）的基石。作为开发者，我们设计的每一个函数，都在参与构建这个安全的、可预测的系统。