Rust 函数

函数是 Rust 程序的基本组成部分。本章节将介绍 Rust 函数的定义和使用。

函数定义

在 Rust 中，使用 fn 关键字定义函数：

fn main() {
    println!("Hello, world!");
    
    greet();
    let result = add(5, 3);
    println!("5 + 3 = {}", result);
}

fn greet() {
    println!("Hello from greet function!");
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

函数参数

函数可以接受参数，参数需要指定类型：

fn print_number(x: i32) {
    println!("The number is: {}", x);
}

fn main() {
    print_number(42);
}

函数返回值

函数可以返回值，返回类型在箭头 -> 后面指定：

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    let sum = add(5, 3);
    println!("Sum: {}", sum);
}

注意：在 Rust 中，函数的最后一个表达式就是返回值，不需要使用 return 关键字（除非需要提前返回）。

提前返回

使用 return 关键字可以提前从函数返回：

fn divide(a: i32, b: i32) -> Option<f64> {
    if b == 0 {
        return None;
    }
    Some(a as f64 / b as f64)
}

fn main() {
    match divide(10, 2) {
        Some(result) => println!("Result: {}", result),
        None => println!("Cannot divide by zero"),
    }
}

函数参数模式

Rust 函数参数支持模式匹配：

fn print_coordinates(&(x, y): &(i32, i32)) {
    println!("x: {}, y: {}", x, y);
}

fn main() {
    let point = (3, 5);
    print_coordinates(&point);
}

函数作为参数

Rust 支持将函数作为参数传递：

fn apply<F>(f: F) where F: FnOnce() {
    f();
}

fn main() {
    let hello = || println!("Hello from closure!");
    apply(hello);
}

高阶函数

函数可以返回其他函数：

fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
    move |y| x + y
}

fn main() {
    let add5 = make_adder(5);
    println!("5 + 3 = {}", add5(3));
}

递归函数

函数可以调用自身，这就是递归：

fn factorial(n: u64) -> u64 {
    if n <= 1 {
        1
    } else {
        n * factorial(n - 1)
    }
}

fn main() {
    println!("5! = {}", factorial(5));
}

函数命名规范

Rust 函数命名使用蛇形命名法（snake_case）：

• 小写字母
• 单词之间用下划线分隔

fn calculate_area(radius: f64) -> f64 {
    std::f64::consts::PI * radius * radius
}

总结

• 使用 fn 关键字定义函数
• 函数参数需要指定类型
• 函数返回类型在箭头 -> 后面指定
• 函数的最后一个表达式就是返回值
• 使用 return 关键字可以提前返回
• Rust 支持函数作为参数和返回值
• 函数可以递归调用
• 函数命名使用蛇形命名法

通过本章节的学习，你应该已经掌握了 Rust 函数的定义和使用方法，可以在你的程序中使用函数来组织代码了。