Rust 函数详解

rust 支持多种编程范式，但更偏向于函数式，函数在 rust 中是“一等公民”，函数可以作为数据在程序中进行传递。跟 c、c++ 一样， rust 也有一个唯一的程序入口 main 函数。

示例：程序入口 main 函数

fn main() {
    println!("hello, world!");
}

rust 使用 fn 关键字来声明和定义函数，使用 snake case 风格来命名函数，即所有的字母小写并使用下划线分隔单词。函数可以有参数，并且每个函数都有返回值。

函数参数

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

示例：

// 定义一个无参函数
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
    }
}

相关资料

rust programming language

the rust reference

rust by example

rustprimer

到此这篇关于rust 函数的文章就介绍到这了,更多相关rust 函数内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！