rust函数

一 、函数定义

（一）格式
使用fn关键字
fn是 function 的缩写
1.无返回值的

fn 函数名 ( [paraname: type]... ) {
     函数体
}
1
2
3

参数必须声明参数名称和类型
函数定义时指定的参数叫做 形参。调用时传递给函数的参数叫做 实参。

例子

fn another_function() {
    println!("Hello, runoob!");
}
1
2
3

2.有返回值的
（1）使用 return 关键字指定返回值

fn 函数名 ( [paraname: type]... ) -> 类型{
     return value;
}
1
2
3

（2）不使用return语句，而使用结尾表达式作为返回值
结尾表达式不能由分号 ; 结尾

function function_name() -> return_type {
     value
}
1
2
3

例子

fn main(){
     println!("pi value is {}",get_pi());
     println!("pi value is {}",get_pi2());
}
fn get_pi()->f64 {
     22.0/7.0
}
fn get_pi2()->f64 {
     return 22.0/7.0;
}
编译运行结果如下
pi value is 3.142857142857143
pi value is 3.142857142857143
1
2
3
4
5
6
7
8
9
10
11
12
13

（二）语句和表达式
函数体由一系列的语句和一个可选的结尾表达式构成

Rust区分语句与表达式，其他语言并没有这样的区别。
语句（Statements）是执行一些操作但没有返回值的指令。
表达式（Expressions）计算并产生一个返回值。
语句与表达式的一个区别是语句以分号结尾，而表达式没有分号。

下列是语句
let y = 6;
函数定义是语句。

以下是表达式
7
b + 2
函数调用是一个表达式。
宏调用是一个表达式。
用大括号创建的一个块作用域也是一个表达式，例如：

fn main() {
    let x = 5;
    let y = {
        let x = 3;
        x + 1
    };
    println!("x的值为 : {}", x);
    println!("y的值为 : {}", y);
}
1
2
3
4
5
6
7
8
9

其中

{
     let x = 3;
     x + 1
}
1
2
3
4

就是一个表达式。
注意 x+1 这一行在结尾没有分号。表达式的结尾没有分号。如果在表达式的结尾加上分号，它就变成了语句。

二、函数使用

（一）
语法格式

function_name(val1, val2, valN);
1

例子

fn main(){
     fn_hello();
}
fn fn_hello(){
     println!("hello from function fn_hello ");
}
1
2
3
4
5
6

（二）传递参数
有两种传递参数的方法，一种是把值直接传递给函数，另一种是把值的内存地址传递给函数。
1.值传递
就是把形参变量赋值为传递的值。因为是赋值，所以形参和实参各自保存了相同的值，互不影响。
范例

fn main(){
     let no:i32 = 5;
     mutate_no_to_zero(no);
     println!("The value of no is:{}",no);
}
fn mutate_no_to_zero(mut param_no: i32) {
     param_no = param_no*0;
     println!("param_no value is :{}",param_no);
}
编译运行结果如下
param_no value is :0
The value of no is:5
1
2
3
4
5
6
7
8
9
10
11
12

2.引用传递
把当前变量的内存地址传递给函数。实参和形参都共同指向了同一个内存地址。
语法格式如下

fn function_name(parameter: &data_type) {
}
1
2

范例

fn main() {
     let mut no:i32 = 5;
     mutate_no_to_zero(&mut no);
     println!("The value of no is:{}",no);
}
fn mutate_no_to_zero(param_no:&mut i32){
     *param_no = 0; //解引用操作
}
编译运行结果如下
The value of no is 0.
1
2
3
4
5
6
7
8
9
10

（三）函数作为参数
在Rust中，函数可以作为参数传递给其他函数，也可以作为函数的返回值。
示例：

fn add(a: i32, b: i32) -> i32 {
     a + b
}
fn subtract(a: i32, b: i32) -> i32 {
     a - b
}
fn calculate(op: fn(i32, i32) -> i32, a: i32, b: i32) -> i32 {
     op(a, b)
}
fn main() {
     let result1 = calculate(add, 3, 5);
     let result2 = calculate(subtract, 8, 4);
     println!("Result 1: {}", result1);
     println!("Result 2: {}", result2);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15