函数指针类型 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) -> R | impl 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,可以自由复制和作为闭包使用。不捕获环境的闭包可以自动转为函数指针。函数指针适合回调、策略模式和函数表等场景,需要捕获环境时则应使用闭包。