Rust泛型与特性

泛型

泛型编程是现代编程语言中重要的机制

C++是通过模板来实现泛型的，而C语言中是没有泛型的

泛型是用来表达抽象类型的机制，用于功能确定，但是数据类型不确定的类型

函数中的泛型

下面这个是没有泛型版本的取数组中最大值的函数

fn max(array: &[i32]) -> i32 {let mut max_index = 0;let mut i = 1;while i < array.len() {if array[i] > array[max_index] {max_index = i;}i += 1;}array[max_index]
}fn main() {let a = [2, 4, 6, 3, 1];println!("max = {}", max(&a));
}

显然只能对i32类型的数字进行选择，如果使用泛型，就是这样的

fn max<T>(array: &[T]) -> T {let mut max_index = 0;let mut i = 1;while i < array.len() {if array[i] > array[max_index] {max_index = i;}i += 1;}array[max_index]
}

我们只需要在函数后面加上<T>即可表示一个泛型类型

结构体与枚举中的泛型

结构体和枚举中也是可以使用泛型的

struct Point<T> {x: T,y: T
}

rust中自带的option和result枚举就是泛型枚举

enum Option<T> {Some(T),None,
}enum Result<T, E> {Ok(T),Err(E),
}

结构体和枚举都是定义泛型的，而两者都可以实现方法，那么方法也应该可以实现泛型

struct Point<T> {x: T,y: T,
}impl<T> Point<T> {fn x(&self) -> &T {&self.x}
}fn main() {let p = Point { x: 1, y: 2 };println!("p.x = {}", p.x());
}

需要注意的是，impl之后必须要有泛型的定义，在imple之中也可以定义其他泛型的方法

impl<T, U> Point<T, U> {fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {Point {x: self.x,y: other.y,}}
}

特性（trait）

这个概念其实类似于接口，是一种行为规范，类似于C++中的接口类（但不完全相同），用于标识一个类有哪些方法

例如

trait Descriptive {fn describe(&self) -> String;
}

这就意味着，如果我们想要用这个trait，就必须要实现descirbe这个方法

例如

struct Person {name: String,age: u8
}impl Descriptive for Person {fn describe(&self) -> String {format!("{} {}", self.name, self.age)}
}

在这个例子中，我们实现了一个结构体（Persion），我们想让这个结构体拥有Descriptive这个特性（trait），但是这个trait要求必须实现describe方法，因此我们impl实现了一下

格式就是

impl <特性名> for <所实现的类型名>

Rust的一个结构体（一个类）可以有多个Trait

但是我们使用impl语句一次只能定义一个Trait

默认特性

我们可以给特性定义方法，这些方法称为默认方法

我们在给对象实现Trait的时候，可以不实现默认方法，这样就是直接用的

如果在给类实现Trait的时候，重写了对应的方法，那么调用的时候就是调用重写的方法

这里我们来讲一讲Rust的设计理念

在C++中，类可以定义成员变量和成员函数，但是到了Rust，把成员变量全部归给类结构体，只负责保存字段，而Trait则只负责定义行为，也就是成员函数

那我们在定义Trait的时候其实就类似于定义C++的接口类

既可以定义纯虚函数，也可以定义普通的虚函数

当我们给结构体赋予Trait的时候，就可以重写

这样做的好处是什么

显而易见的是Trait可以被复用了，多个struct可以实现同一个Trait

在Rust中是没有继承这个概念的，因为他不像传统的面向对象语言，在Rust中主要是通过组合和多态来实现功能的，又由于Trait比传统的多态的功能更加强大，所以Rust采用了这种思路

示例代码如下

trait Descriptive {fn describe(&self) -> String {String::from("[Object]")}
}struct Person {name: String,age: u8
}impl Descriptive for Person {fn describe(&self) -> String {format!("{} {}", self.name, self.age)}
}fn main() {let cali = Person {name: String::from("Cali"),age: 24};println!("{}", cali.describe());
}

Trait作为参数

有时候我们需要传递一个函数作为参数，例如回调函数，在C++中是通过传递函数对象实现的，但是在Rust中我们可以传递特性

例如

fn output(object: impl Descriptive) {println!("{}", object.describe());
}

也可以通过泛型的语法糖，类似于C++中的特化模板

fn output_two<T: Descriptive>(arg1: T, arg2: T) {println!("{}", arg1.describe());println!("{}", arg2.describe());
}

如果特性作为参数时涉及多个特性，可以用+来连接，例如

fn notify(item: impl Summary + Display)
fn notify<T: Summary + Display>(item: T)

这种使用方法只能用于标识类型，在语句中时不能使用的

有时候特性会非常多，可以用下面的方法来简化

fn some_function<T, U>(t: T, u: U) -> i32where T: Display + Clone,U: Clone + Debug

那我们最终实现的最大值就可以这样写

trait Comparable {fn compare(&self, object: &Self) -> i8;
}fn max<T: Comparable>(array: &[T]) -> &T {let mut max_index = 0;let mut i = 1;while i < array.len() {if array[i].compare(&array[max_index]) > 0 {max_index = i;}i += 1;}&array[max_index]
}impl Comparable for f64 {fn compare(&self, object: &f64) -> i8 {if &self > &object { 1 }else if &self == &object { 0 }else { -1 }}
}fn main() {let arr = [1.0, 3.0, 5.0, 4.0, 2.0];println!("maximum of arr is {}", max(&arr));
}

特性做返回值

我们不能单独返回特性，只能够返回具有特性的实例，因此如果多个结构体实现了同一个特性，就需要确保返回值是相同类型的实例，并且也必须是实现了特性的对象才能返回

fn person() -> impl Descriptive {Person {name: String::from("Cali"),age: 24}
}

给结构体实现方法

impl还可以给结构体赋予方法，并且可以要求实现的先后顺序

struct A<T> {}impl<T: B + C> A<T> {fn d(&self) {}
}

这个意思是要给泛型A赋予一个方法d，但是这个方法必须要在实现了B和C之后才能实现