Function 如何将函数作为参数传递给另一个函数？

我一直坚持将函数作为参数传递：

fn first(
    a: *mut *const u8
) -> c_int;

fn second(
    b: u16,
    functionfirst: first()
) -> c_int;

我得到的错误是：

我尝试的是：

type first = Option<unsafe extern "C" fn(a: *mut *const u8) -> c_int>;

unsafe extern "C" fn second(
    b: u16,
    functionfirst: first
) -> c_int;

type first=选项c_int>；
不安全外部“C”fn秒(
b:u16，
功能第一：第一
)->c_int；

这也有一个错误：

错误：应为`；`，发现`=`
首先键入=选项c_int>；
^期望``

灵感来源于来源

fn find
（mut谓词：P）
哪里
P:FnMut（&str）->bool，
{
谓词（“x”）；
}
fn main（）{
查找（|x |{println！（“Printed{}”，x）；返回true；}）；
}

:-

接受不可变接收器的呼叫运算符的版本。 Fn的实例可以在不改变状态的情况下重复调用

:-

接受可变接收器的呼叫运算符的版本。 FnMut的实例可以重复调用，并且可能会改变状态

---

你只是突然放弃声明，所以有点难以理解。此外，这不仅仅是使用Rust函数的Rust代码，这似乎是FFI和与其他系统的接口Rust

参数类型必须是类型，

first（）

不是类型，而是函数（调用）。函数指针的类型是

fn（args…->result

。尽管这告诉rustc要使用Rust调用约定，但考虑到所涉及的非Rust类型（尽管Rust和非Rust数字类型的混合听起来是个坏主意），您可能需要一个

extern

来确保正确的ABI：

fn秒(
b:u16，
functionfirst:extern fn（*mut*const u8）->c_int
)->c_int；

我尝试的内容：[……]这也有一个错误：

提供完整的代码和错误（也称为最小可重复示例）往往很有用，因为虽然我确实在您的代码片段中遇到错误，但它与您得到的代码片段无关

我刚刚得到一个错误，一个自由函数需要一个主体，这可以通过将声明放在

extern

块中来解决（表示我们声明的是由其他东西提供的函数，而不是定义函数），然后编译器抱怨

不安全

，因为

外部

块不允许

不安全

（因为它们中声明的函数定义上是不安全的）

---

在解决了这些问题之后，两个函数都进行了编译，只需要很少的代价：

要将一个函数传递给Rust中的另一个函数，需要使用一个带有特征绑定的泛型参数。最基本的例子是：

fn hi_5<F>(func: F) where F: Fn(u32) -> u32, {
    println!("Hi, {}", func(5));
}
fn square(x: u32) -> u32 {
    x*x
}
hi_5(square);

fn hi_5（func:F），其中F:fn（u32）->u32{
println！（“Hi，{}”，func（5））；
}
fn方形（x:u32）->u32{
x*x
}
hi_5（广场）；

为了解决这个问题，我们在这里声明了一个名为

hi_5

（

fn hi_5

）的函数，它有一个通用参数F（

），并接受一个类型为F的参数（

func:F

）。F泛型类型有一个

Fn（u32）->u32

特征绑定在它上面（

其中F:Fn（u32）->u32

），这意味着它是一个函数，它接受一个

u32

，并返回一个

u32

Rust中有三个

Fn

特性，尽管它们只有在处理闭包时才重要

• Fn

  特质是你最常使用的。它一成不变地借用了一切 来自环境的变量

• FnMut

  trait可变地借用了环境，这意味着它可以 更改其值

• FnOnce

  trait将使用的环境变量移动到 关闭。

  Once

  部分来自这样一个事实，即调用 函数一旦被调用，就不能再次调用

如果你不明白“环境”是什么，请查看

error: expected `;`, found `=`

type first = Option<unsafe extern "C" fn(a: *mut *const u8) -> c_int>;

           ^ expected `;`

fn find<P>(mut predicate: P)
    where
        P: FnMut(&str) -> bool,
    {
        predicate("x");
    }
fn main() {
    find(|x| {println!("Printed {}", x); return true; });
}

fn first(a: *mut *const u8) -> c_int;
fn second(b: u16, functionfirst: first()) -> c_int;

fn hi_5<F>(func: F) where F: Fn(u32) -> u32, {
    println!("Hi, {}", func(5));
}
fn square(x: u32) -> u32 {
    x*x
}
hi_5(square);