函数指针类型 fn ​

什么是函数指针 ​

函数指针是指向函数的变量。在 Rust 中,每个函数都有一个唯一的匿名类型,但所有签名相同的函数都可以被转换成函数指针类型 fn。函数指针类型的写法和函数签名类似:fn(参数类型) -> 返回类型。

rust
// 两个签名相同的函数
fn add(a: i32, b: i32) -> i32 { a + b }
fn multiply(a: i32, b: i32) -> i32 { a * b }

fn main() {
    // 函数指针类型:fn(i32, i32) -> i32
    let op: fn(i32, i32) -> i32 = add;
    println!("op(3, 4) = {}", op(3, 4));  // 7

    // 可以重新赋值为另一个签名相同的函数
    let op: fn(i32, i32) -> i32 = multiply;
    println!("op(3, 4) = {}", op(3, 4));  // 12
}

函数指针的类型标注 ​

rust
fn square(n: i32) -> i32 { n * n }
fn double(n: i32) -> i32 { n * 2 }
fn negate(n: i32) -> i32 { -n }

fn main() {
    // 显式标注类型
    let f: fn(i32) -> i32 = square;
    println!("{}", f(5));  // 25

    // 存储在集合中
    let operations: Vec<fn(i32) -> i32> = vec![square, double, negate];

    let value = 7;
    for op in &operations {
        println!("op({}) = {}", value, op(value));
    }
    // 输出:49, 14, -7

    // 无参数无返回值的函数指针
    fn hello() { println!("你好"); }
    fn world() { println!("世界"); }

    let greetings: [fn(); 2] = [hello, world];
    for g in &greetings {
        g();
    }
}

函数指针作为参数 ​

函数指针可以作为参数传递给其他函数,实现回调或策略模式。

rust
// 接受函数指针作为参数
fn apply(value: i32, func: fn(i32) -> i32) -> i32 {
    func(value)
}

// 对集合每个元素应用函数
fn map_values(data: &[i32], func: fn(i32) -> i32) -> Vec<i32> {
    data.iter().map(|&x| func(x)).collect()
}

fn square(n: i32) -> i32 { n * n }
fn abs_val(n: i32) -> i32 { n.abs() }

fn main() {
    println!("apply(5, square) = {}", apply(5, square));
    println!("apply(-3, abs_val) = {}", apply(-3, abs_val));

    let data = vec![-3, 1, -4, 1, 5, -9];
    let squared = map_values(&data, square);
    let absoluted = map_values(&data, abs_val);

    println!("原始:{:?}", data);
    println!("平方:{:?}", squared);
    println!("绝对值:{:?}", absoluted);
}

函数指针 vs 闭包 ​

函数指针 fn 和闭包 trait(Fn、FnMut、FnOnce)是不同的。函数指针不能捕获环境变量,但所有函数指针都自动实现了三个闭包 trait。

特性函数指针 fn闭包 Fn/FnMut/FnOnce
捕获环境不能能
大小固定(一个指针大小)取决于捕获的变量
存储在集合中容易(类型统一)需要 Box<dyn Fn>
作为参数fn(T) -> Rimpl Fn(T) -> R
实现闭包 trait自动实现所有三个取决于如何捕获
rust
fn add_one(n: i32) -> i32 { n + 1 }

fn main() {
    // 函数指针可以当闭包用
    let nums = vec![1, 2, 3];
    let result: Vec<i32> = nums.iter().map(|&x| add_one(x)).collect();
    println!("{:?}", result);

    // 函数名可以直接传给接受 Fn 的地方
    let result2: Vec<i32> = nums.iter().copied().map(add_one).collect();
    println!("{:?}", result2);

    // 闭包如果不捕获环境,可以转成函数指针
    let f: fn(i32) -> i32 = |x| x * 2;
    println!("{}", f(21));  // 42

    // 捕获了环境的闭包不能转成函数指针
    let factor = 3;
    // let f: fn(i32) -> i32 = |x| x * factor;  // 编译错误
    let f = |x: i32| x * factor;  // 这是闭包,不是函数指针
    println!("{}", f(10));  // 30
}

基本示例 ​

用函数指针实现一个简单的计算器:

rust
fn add(a: f64, b: f64) -> f64 { a + b }
fn sub(a: f64, b: f64) -> f64 { a - b }
fn mul(a: f64, b: f64) -> f64 { a * b }
fn div(a: f64, b: f64) -> f64 {
    if b == 0.0 { f64::NAN } else { a / b }
}

// 根据运算符选择函数
fn get_operation(op: char) -> Option<fn(f64, f64) -> f64> {
    match op {
        '+' => Some(add),
        '-' => Some(sub),
        '*' => Some(mul),
        '/' => Some(div),
        _ => None,
    }
}

// 批量计算
fn batch_calculate(
    pairs: &[(f64, f64)],
    operation: fn(f64, f64) -> f64,
) -> Vec<f64> {
    pairs.iter().map(|&(a, b)| operation(a, b)).collect()
}

fn main() {
    // 根据符号获取操作函数
    let operators = ['+', '-', '*', '/', '%'];
    let a = 10.0;
    let b = 3.0;

    for &op in &operators {
        match get_operation(op) {
            Some(func) => println!("{} {} {} = {:.2}", a, op, b, func(a, b)),
            None => println!("不支持的运算符:{}", op),
        }
    }

    println!();

    // 批量计算
    let pairs = vec![(1.0, 2.0), (3.0, 4.0), (5.0, 6.0)];
    let sums = batch_calculate(&pairs, add);
    let products = batch_calculate(&pairs, mul);
    println!("和:{:?}", sums);
    println!("积:{:?}", products);
}

常见问题 ​

问题一:函数指针的大小是多少?

函数指针的大小是一个指针的大小(64 位系统上是 8 字节),和 usize 一样。闭包的大小取决于它捕获了多少变量。

问题二:函数指针可以为 null 吗?

不可以。Rust 的函数指针不能为 null,它总是指向一个有效的函数。如果需要表示"可能没有函数",用 Option<fn(T) -> R>。

问题三:什么时候用函数指针,什么时候用闭包 trait?

如果不需要捕获环境变量,函数指针更简单直接。如果需要捕获环境或者需要更通用的接口,用闭包 trait(impl Fn、&dyn Fn、Box<dyn Fn>)。

问题四:函数指针实现了哪些 trait?

函数指针实现了 Copy、Clone、Send、Sync、Fn、FnMut、FnOnce。

适用场景 ​

  • 回调函数:把函数作为参数传递
  • 策略模式:根据条件选择不同的函数执行
  • 函数表/分发表:用数组或 HashMap 存储一组函数
  • FFI 接口:和 C 代码交互时传递函数指针
  • 简单的高阶函数:不需要捕获环境的场景

注意事项 ​

  • 函数指针类型写法:fn(参数类型) -> 返回类型
  • 函数指针不能捕获环境变量
  • 不捕获环境的闭包可以自动转为函数指针
  • 函数指针实现了 Copy,可以随意复制
  • 函数指针不能为 null,用 Option 表示可选
  • 函数指针的大小固定(一个指针),闭包大小不固定

总结 ​

函数指针类型 fn 让你可以把函数当作值来传递和存储。它的类型签名和函数签名类似:fn(参数类型) -> 返回类型。函数指针不能捕获环境变量,但实现了 Copy 和所有闭包 trait,可以自由复制和作为闭包使用。不捕获环境的闭包可以自动转为函数指针。函数指针适合回调、策略模式和函数表等场景,需要捕获环境时则应使用闭包。