24.泛型(Generic)

泛型是运行时指定数据类型的一种机制。好处是通过高度的抽象，使用一套代码应用多种数据类型。比如我们的向量，可以使用数值类型，也可以使用字符串类型。泛型是可以保证数据安全和类型安全的，还同时减少代码量。

Rust 语言中的泛型主要包含 泛型集合、泛型结构体、泛型函数、范型枚举 和 特质 。

Rust 使用使用 <T> 语法来实现泛型, 其中 T 可以是任意数据类型。

泛型集合

我们之前用过的向量。我们可以创建 i32 类型的，也可以创建字符串类型的，但是一旦确定了类型，就不能添加其他类型，否则报错。

1
2
let mut v:Vec<i32> =vec![1,2,3];
v.push("4");//此处会报错 ^^^ expected `i32`, found `&str`

说明向量需要的是 i32 类型的值，现在给了一个字符串。从这点看，泛型 让集合更通用，也更安全。

泛型结构体

定义语法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct 结构体名称<T> {
   元素:T,
}


struct Data<T> {
   value:T,
}

fn main() {
    let t:Data<i32> = Data{value:100};
    println!("值:{} ",t.value);//输出 值:100
    let t:Data<f64> = Data{value:66.00};
    println!("值:{} ",t.value);//输出 值:66
}

特质 Trait

可以把这个特质（traits）对标其他语言的接口，都是对行为的抽象。使用 trait关键字用来定义。特质，可以包含具体的方法，也可以包含抽象的方法。

1
2
3
4
5
6
7
8
9
trait some_trait {
   // 没有任何实现的虚方法
   fn method1(&self);

   // 有具体实现的普通方法
   fn method2(&self){
      //方法的具体代码
   }
}

实现特质

Rust 使用 impl for 为每个结构体实现某个特质。impl 是 implement 的缩写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
struct Book {
    name: String,
    id: u32,
    author: String,
}

trait ShowBook {
    fn Show(&self);
}

impl ShowBook for Book{
    fn Show(&self) {
        println!("Id:{},Name:{},Author:{}",self.id,self.name,self.author);
    }
}

fn main() {
		let book = Book{
        id:1,
        name: String::from("Go语言极简一本通"),
        author: String::from("欢喜")
    };
    book.Show();//输出 Id:1,Name:Go语言极简一本通,Author:欢喜
}

泛型函数

主要是指参数是泛型类型，不要求所有参数都必须是泛型参数，可以是某一个参数是泛型类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
fn 方法名<T[:特质名称]>(参数1:T, ...) {

   // 函数实现代码
}


fn show2<T:Display>(t:T){
    println!("{}",t);
}

impl Display for Book{
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        println!("Id:{},Name:{},Author:{}",self.id,self.name,self.author);
        let r=Result::Ok(());
        return r;
    }
}

show2(book);//输出 Id:1,Name:Go语言极简一本通,Author:欢喜

添加微信 公众号更多内容
wechat gzh