Rust 函数

  |   0 评论   |   0 浏览

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

示例:程序入口 main 函数

1fn main() {
2    println!("Hello, world!");
3}

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

函数参数

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

示例

1// 定义一个无参函数
2fn function() {
3    println!("A function with no parameters.");
4}
5
6// 定义一个有参函数
7fn hello(name: &str) {
8  println!("Hello, {}.", name);
9}

函数返回值

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

1fn main() -> () {
2    //statements
3  }

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

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

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

1fn main() {
2    let x = plus_one(5);
3
4    println!("The value of x is: {}", x);
5}
6
7fn plus_one(x: i32) -> i32 {
8    x + 1
9}

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

示例:在函数中使用 return

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

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

示例

1fn main() {
2  println!("hello");
3  diverging();
4  println!("world");
5}
6fn diverging() -> ! {
7  panic!("This function will never return");
8}

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

高阶函数

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

函数指针类型

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

示例

 1// 函数定义
 2fn inc(n: i32) -> i32 {
 3    n + 1
 4}
 5
 6// 使用 `type` 给函数指针类型起一个别名
 7type IncType = fn(i32) -> i32;
 8
 9fn main() {
10    // 使用函数指针类型 `fn(i32) -> i32`
11    let func: fn(i32) -> i32 = inc;
12    println!("3 + 1 = {}", func(3));
13
14    // 使用函数指针类型的别名 `IncType`
15    let func: IncType = inc;
16    println!("4 + 1 = {}", func(4));
17}

函数作为参数

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

示例:高阶函数

 1fn main() {
 2  println!("3 + 1 = {}", process(3, inc));
 3  println!("3 - 1 = {}", process(3, dec));
 4}
 5fn inc(n: i32) -> i32 {
 6  n + 1
 7}
 8fn dec(n: i32) -> i32 {
 9  n - 1
10}
11// process 是一个高阶函数,它有两个参数,一个类型为 `i32`,另一个类型为 `fn(i32)->i32`
12fn process(n: i32, func: fn(i32) -> i32) -> i32 {
13  func(n)
14}

函数作为返回值

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

示例

 1fn main() {
 2    let a = [1,2,3,4,5,6,7];
 3    let mut b = Vec::<i32>::new();
 4    for i in &a {
 5        b.push(get_func(*i)(*i));
 6    }
 7    println!("{:?}", b);
 8 }
 9
10 // 若传入的参数为偶数,返回 `inc`,否则返回 `dec`
11 fn get_func(n: i32) -> fn(i32) -> i32 {
12    fn inc(n: i32) -> i32 {
13        n + 1
14    }
15    fn dec(n: i32) -> i32 {
16        n - 1
17    }
18    if n % 2 == 0 {
19        inc
20    } else {
21        dec
22    }
23}

相关资料

Rust Programming Language

The Rust Reference

Rust By Example

RustPrimer