Rust 函数详解

时间2024-02-10 23:27:03发布访客分类其他前端知识浏览1100

导读：收集整理的这篇文章主要介绍了Rust 函数详解，觉得挺不错的，现在分享给大家，也给大家做个参考。目录函数参数函数返回值高阶函数函数指针类型函数作为参数函数作为返回值相关资料Rust 支...

收集整理的这篇文章主要介绍了Rust 函数详解，觉得挺不错的，现在分享给大家，也给大家做个参考。

函数参数

参数的声明方式：参数名 + 冒号 + 参数类型

示例：

// 定义一个无参函数fn function() {
        println!("A function wITh no parameters.");
}
    // 定义一个有参函数fn hello(name: &
str) {
  println!("Hello, {
}
    .", name);
}

函数返回值

在 Rust 中所有函数都有返回值，main 函数也不例外，main 函数的返回值是 ()（一个空的元组）。在 Rust 中，当一个函数返回 () 时，可以省略返回值类型的声明。main 函数的完整形式如下：

  fn main() ->
 () {
    //statements  }

() 通常被称为 unit 或者 unit tyPE，它其实类似于 C/C++、Java、C#中的 void 类型。

若函数有其他类型返回值，则需使用 -> 显式标明返回值类型。像 C/C++ 或 Java 等语言在函数中需要用 return 语句返回一个值，Rust 与它们不一样，Rust 默认将函数中最后一个表达式的结果作为返回值。

示例：定义一个有返回值的函数

fn main() {
        let x = plus_one(5);
    println!("The value of x is: {
}
    ", x);
}
    fn plus_one(x: i32) ->
 i32 {
    x + 1}

Rust 也有 return 关键字，不过一般用于提前返回。

示例：在函数中使用 return

fn main() {
      let a = [1,3,2,5,9,8];
  println!("There is 7 in the array: {
}
    ", find(7, &
    a));
  println!("There is 8 in the array: {
}
    ", find(8, &
    a));
}
    fn find(n: i32, a: &
    [i32]) ->
 bool {
  for i in a {
    if *i == n {
          return true;
    }
  }
      false // 这里也可以改为 `return false;
`，但这就不是 Rust 的编程风格了}

在 Rust 中还有一种“没有返回值”的函数，称之为发散函数（diverging function）。其实，它根本就不返回，它使用感叹号 ! 作为返回类型。

示例：

fn main() {
      println!("hello");
      diverging();
      println!("world");
}
    fn diverging() ->
 ! {
      panic!("This function will never return");
}

发散函数一般都以 panic! 宏调用或其他调用其他发散函数结束，所以，调用发散函数会导致当前线程崩溃。

高阶函数

高阶函数与普通函数的不同在于，它可以使用一个或多个函数作为参数，可以将函数作为返回值。既然函数可以作为参数和返回值，那么函数也应该有一种相对应的数据类型，那就是：函数指针类型。

函数指针类型

函数指针类型使用 fn 关键字定义，在编译时该类型指向一个已知函数参数和返回值类型，但函数体未知的函数。

示例：

// 函数定义fn inc(n: i32) ->
 i32 {
    n + 1}
    // 使用 `type` 给函数指针类型起一个别名type IncType = fn(i32) ->
     i32;
fn main() {
        // 使用函数指针类型 `fn(i32) ->
     i32`    let func: fn(i32) ->
     i32 = inc;
    println!("3 + 1 = {
}
    ", func(3));
        // 使用函数指针类型的别名 `IncType`    let func: IncType = inc;
    println!("4 + 1 = {
}
    ", func(4));
}

函数作为参数

函数作为参数，其声明与普通参数一样。

示例：高阶函数

fn main() {
  println!("3 + 1 = {
}
    ", process(3, inc));
  println!("3 - 1 = {
}
    ", process(3, dec));
}
    fn inc(n: i32) ->
 i32 {
  n + 1}
    fn dec(n: i32) ->
 i32 {
  n - 1}
    // process 是一个高阶函数，它有两个参数，一个类型为 `i32`，另一个类型为 `fn(i32)->
    i32`fn process(n: i32, func: fn(i32) ->
     i32) ->
 i32 {
  func(n)}

函数作为返回值

函数作为返回值，其声明与普通函数的返回值类型声明一样。

示例：

fn main() {
        let a = [1,2,3,4,5,6,7];
        let mut b = Vec::i32>
    ::new();
        for i in &
a {
            b.push(get_func(*i)(*i));
    }
    println!("{
:?}
    ", b);
 }
     // 若传入的参数为偶数，返回 `inc`，否则返回 `dec` fn get_func(n: i32) ->
     fn(i32) ->
 i32 {
        fn inc(n: i32) ->
 i32 {
        n + 1    }
        fn dec(n: i32) ->
 i32 {
        n - 1    }
    if n % 2 == 0 {
        inc    }
 else {
        dec    }
}