函数与方法

函数与方法

函数

要声明一个函数，需要使用关键字fn，后面跟上函数名，比如

1. fn add_one(x: i32) -> i32 {
2. x + 1
3. }

其中函数参数的类型不能省略，可以有多个参数，但是最多只能返回一个值，提前返回使用return关键字。Rust编译器会对未使用的函数提出警告，可以使用属性#[allow(dead_code)]禁用无效代码检查。

Rust有一个特殊特性适用于发散函数 (diverging function)，它不返回：

1. fn diverges() -> ! {
2. panic!("This function never returns!");
3. }

其中panic!是一个宏，使当前执行线程崩溃并打印给定信息。返回类型!可用作任何类型：

1. let x: i32 = diverges();
2. let y: String = diverges();

匿名函数

Rust使用闭包 (closure) 来创建匿名函数：

1. let num = 5;
2. let plus_num = |x: i32| x + num;

其中闭包plus_num借用了它作用域中的let绑定num。如果要让闭包获得所有权，可以使用move关键字：

1. let mut num = 5;

3. {
4. let mut add_num = move |x: i32| num += x;   // 闭包通过move获取了num的所有权

6. add_num(5);
7. }

9. // 下面的num在被move之后还能继续使用是因为其实现了Copy特性
10. // 具体可见所有权(Owership)章节
11. assert_eq!(5, num);

高阶函数

Rust 还支持高阶函数 (high order function)，允许把闭包作为参数来生成新的函数：

1. fn add_one(x: i32) -> i32 { x + 1 }

3. fn apply<F>(f: F, y: i32) -> i32
4. where F: Fn(i32) -> i32
5. {
6. f(y) * y
7. }

9. fn factory(x: i32) -> Box<Fn(i32) -> i32> {
10. Box::new(move |y| x + y)
11. }

13. fn main() {
14. let transform: fn(i32) -> i32 = add_one;
15. let f0 = add_one(2i32) * 2;
16. let f1 = apply(add_one, 2);
17. let f2 = apply(transform, 2);
18. println!("{}, {}, {}", f0, f1, f2);

20. let closure = |x: i32| x + 1;
21. let c0 = closure(2i32) * 2;
22. let c1 = apply(closure, 2);
23. let c2 = apply(|x| x + 1, 2);
24. println!("{}, {}, {}", c0, c1, c2);

26. let box_fn = factory(1i32);
27. let b0 = box_fn(2i32) * 2;
28. let b1 = (*box_fn)(2i32) * 2;
29. let b2 = (&box_fn)(2i32) * 2;
30. println!("{}, {}, {}", b0, b1, b2);

32. let add_num = &(*box_fn);
33. let translate: &Fn(i32) -> i32 = add_num;
34. let z0 = add_num(2i32) * 2;
35. let z1 = apply(add_num, 2);
36. let z2 = apply(translate, 2);
37. println!("{}, {}, {}", z0, z1, z2);
38. }

方法

Rust通过impl关键字在struct、enum或者trait对象上实现方法调用语法 (method call syntax)。关联函数 (associated function) 的第一个参数通常为self参数，有3种变体：

self，允许实现者移动和修改对象，对应的闭包特性为FnOnce。
&self，既不允许实现者移动对象也不允许修改，对应的闭包特性为Fn。
&mut self，允许实现者修改对象但不允许移动，对应的闭包特性为FnMut。

不含self参数的关联函数称为静态方法 (static method)。

1. struct Circle {
2. x: f64,
3. y: f64,
4. radius: f64,
5. }

7. impl Circle {
8. fn new(x: f64, y: f64, radius: f64) -> Circle {
9. Circle {
10. x: x,
11. y: y,
12. radius: radius,
13. }
14. }

16. fn area(&self) -> f64 {
17. std::f64::consts::PI * (self.radius * self.radius)
18. }
19. }

21. fn main() {
22. let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
23. println!("{}", c.area());

25. // use associated function and method chaining
26. println!("{}", Circle::new(0.0, 0.0, 2.0).area());
27. }