Rust 从 0 到 1 (泛型和特征、集合类型)

泛型

在我们的编程生涯中，经常遇到同一功能的函数处理不同的类型数据，如整合的加法、浮点数的加法等，在不支持泛型的语言中你需要：

fn add_i8(a:i8, b:i8) -> i8 {
    a + b
}
fn add_i32(a:i32, b:i32) -> i32 {
    a + b
}
fn add_f64(a:f64, b:f64) -> f64 {
    a + b
}

在编程的时候，我们经常利用多态。通俗的讲，多态就是好比坦克的炮管，既可以发射普通弹药，也可以发射制导炮弹（导弹），也可以发射贫铀穿甲弹，甚至发射子母弹，没有必要为每一种炮弹都在坦克上分别安装一个专用炮管，即使生产商愿意，炮手也不愿意，累死人啊。所以在编程开发中，我们也需要这样“通用的炮管”，这个“通用的炮管”就是多态。

因此呢，泛型就是一种多态。泛型主要是为了减少代码量，避免程序臃肿，同时也可以丰富语言本身的表达能力。在 Rust 中泛型的声明如下：

fn add<T>(list: &[T]) -> T {
    // do something
}

在上面的代码中 T 就是泛型参数，虽然在 Rust 中泛型参数的名称可以任意取名，但惯例使用 T (T 是 type 的首字母)。名称越短越好，一个字母是最完美的。如何使用泛型来编写上面的 add 函数呢？如下：

fn add<T: std::ops::Add<Output = T>>(x: T, y: T) -> T {
    x + y
}

fn main() {
    let x1 = 3;
    let y1 = 6;
    let x2 = 6.5;
    let y2 = 3.3;

    println!("i32 x + y = {}", add(x1, y1));
    println!("f64 x + y = {}", add(x2, y2));
}

运行结果：

T: std::ops::Add<Output = T> 是对参数的约束，暂且不表。

结构体中使用泛型

在 Rust 中结构体中的字段类型也是可以用泛型来定的，如：

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

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
}

需要注意的是：

• 提前声明，我们在使用泛型参数之前必需要进行声明 Point，才可以在结构体的字段类型中使用 T 来替代具体的类型
• x 和 y 是相同的类型

类型不同则会报错

枚举中使用泛型

Option 枚举是一个拥有泛型参数 T 的枚举类型，其定义为：

enum Option<T> {
    Some(T),
    None,
}

Some(T)，存放了一个类型为 T 的值，因为泛型的存在我们可以在任意一个有返回值的函数中使用 Option<T> 作为返回值，返回的可能是 Some(T) 也可能是 None。 在 Rust 中还有一个枚举 Result，其定义为：

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

如果函数正常运行，则最后返回一个 Ok(T)，T 是函数具体的返回值类型，如果函数异常运行，则返回一个 Err(E)，E 是错误类型。例如打开一个文件：如果成功打开文件，则返回 Ok(std::fs::File)，因此 T 对应的是 std::fs::File 类型；而当打开文件时出现问题时，返回 Err(std::io::Error)，E 对应的就是 std::io::Error 类型。

方法中使用泛型

方法中也是可以使用泛型的，如：

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

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

使用泛型参数前，依然需要提前声明：impl，只有提前声明了，我们才能在Point中使用它，这样 Rust 就知道 Point 的尖括号中的类型是泛型而不是具体类型。需要注意的是，这里的 Point 不再是泛型声明，而是一个完整的结构体类型，因为我们定义的结构体就是 Point 而不再是 Point。

还可以为具体的范型类型实现方法，如：

impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

Point 类型会有一个方法 distance_from_origin，而其他 T 不是 f32 类型的 Point 实例则没有定义此方法。

const 泛型

在 Rust 1.51 版本引入了 const 泛型，如：

fn display_array(arr: [i32; 3]) {
    println!("{:?}", arr);
}
fn main() {
    let arr: [i32; 3] = [1, 2, 3];
    display_array(arr);

    let arr: [i32;2] = [1,2];
    display_array(arr);
}

其运行结果如下：

在 Rust 看来，[i32; 3] 和 [i32; 2] 是两种不同的类型，因此不能完成调用，为了能顺利运行，我们修改代码如下：

fn display_array(arr: &[i32]) {
    println!("{:?}", arr);
}
fn main() {
    let arr: [i32; 3] = [1, 2, 3];
    display_array(&arr);

    let arr: [i32;2] = [1,2];
    display_array(&arr);
}

将参数改为切片即可，为了适配所有的类型，可讲代码改为如下：

fn display_array<T: std::fmt::Debug>(arr: &[T]) {
    println!("{:?}", arr);
}
fn main() {
    let arr: [i32; 3] = [1, 2, 3];
    display_array(&arr);

    let arr: [i32;2] = [1,2];
    display_array(&arr);
}

这里加上 std::fmt::Debug 是为了 println!("{:?}", arr) 能正常工作。

以前 Rust 的一些数组库，在使用的时候都限定长度不超过 32 ，因此需要为每个长度单独实现一个方法，代码极其臃肿，现在 const 泛型即可解决这个问题：

fn display_array<T: std::fmt::Debug, const N: usize>(arr: [T; N]) {
    println!("{:?}", arr);
}
fn main() {
    let arr: [i32; 3] = [1, 2, 3];
    display_array(arr);

    let arr: [i32; 2] = [1, 2];
    display_array(arr);
}

在这里定义了一个类型为 [T; N] 的数组，其中 T 是一个基于类型的泛型参数，这个和之前讲的泛型没有区别，而重点在于 N 这个泛型参数，它是一个基于值的泛型参数！因为它用来替代的是数组的长度。N 就是 const 泛型，定义的语法是 const N: usize，表示 const 泛型 N ，它基于的值类型是 usize。

特征

特征，其实就是其他语言中的接口，具体来说就是不同类型具有相同的行为，我们就可以定义一个特征，然后实现这个这个特征。定义特征是把一些方法组合在一起，目的是定义一个实现某些目标所必需的行为的集合。

如：我们在发文的时候，可以发自己的 Blog 也可以发其他的媒体上面，在我们需要对文章进行总结的时候，总结这个行为是共享的，那么就可以使用特质来实现：

pub trait Summary {
    fn summarize(&self) -> String;
}

代码解释：pub 表示公开的特征，使用 trait 关键字声明一个特征，Summary 是特征名，在大括号中定义该特征的所有方法，如 fn summarize(&self) -> String;。

为类型实现特征

在这里我们以为自己的 Blog 和 Weibo 为例子，看看特征的实现：

pub trait Summary{
    fn summarize(&self);
}

pub struct Blog {
    pub title: String,
    pub author: String,
    pub content: String,
}

pub struct Weibo {
    pub user: String,
    pub content: String,
}

// 为 Blog 实现特征
impl Summary for Blog {
    fn summarize(&self) {
        println!("{} {} blog upload new blog {}", self.author, self.title, self.content);
    }
}

// 为 Webo 实现特征
impl Summary for Weibo {
    fn summarize(&self) {
        println!("weibo user {} post new paper {}", self.user, self.content);
    }
}

fn main(){
    // 结构体实例
    let blog = Blog{title: "hello,world!".to_string(), author: "wh0am1i.com".to_string(), content: "fuck you, nvidia!".to_string()};
    let weibo = Weibo{user: "hello,world!".to_string(), content: "damn~".to_string()};

    // 调用
    blog.summarize();
    weibo.summarize();
}

实现特征的语法与为结构体、枚举实现方法很像：impl Summary for Post，读作“为 Post 类型实现 Summary 特征”，然后在 impl 的花括号中实现该特征的具体方法。

孤儿规则

在 Rust 中特征有一条特别重要的规则： 如果我们要为类型 A 实现特征 T，那么 A 或者 T 至少有一个是在当前作用域中定义的。如：在当前作用域下，我们可以是 Blog 实现 Display 特征，也可以使用 String 实现 Summary 特征，但是你不能在当前作用域为 String 实现 Display 特征，好比你用前朝的剑斩本朝的官，那是不可行的，这条规则就是孤儿规则。

默认实现

特征可以有默认的实现，也可以选择重载该方法：

pub trait Summary {
    fn summarize(&self) {
        println!("Read more...");
    }
}

impl Summary for Post {}

impl Summary for Weibo {
    fn summarize(&self) {
        println!("{}发表了微博{}", self.username, self.content);
    }
}

其运行结果：

默认实现允许调用相同特征中的其他方法，哪怕这些方法没有默认实现。 如：

pub trait Summary {
    fn summarize_author(&self) -> String;

    fn summarize(&self) -> String {
        format!("(Read more from {}...)", self.summarize_author())
    }
}

impl Summary for Weibo {
    fn summarize_author(&self) -> String {
        format!("@{}", self.username)
    }
}
println!("1 new weibo: {}", weibo.summarize());

weibo.summarize() 会先调用 Summary 特征默认实现的 summarize 方法，通过该方法进而调用 Weibo 为 Summary 实现的 summarize_author 方法，最终输出：1 new weibo: (Read more from @horse_ebooks…)。

约束特征

首先我们看定义：

pub fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

T: Summary 被称为特征约束。

如果我们需要强制函数的参数是同一个类型，可以使用特质约束来实现：

pub fn notify<T: Summary>(item1: &T, item2: &T) {}

泛型类型 T 说明了 item1 和 item2 必须拥有同样的类型，同时 T: Summary 说明了 T 必须实现 Summary 特征。

多重约束

我们还可以指定多个约束条件，如：

pub fn notify(item: &(impl Summary + Display)) {}

还可以是：

pub fn notify<T: Summary + Display>(item: &T) {}

Where 约束

当特征约束变得很多时，函数的签名将变得很复杂：

fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {}

虽然不是很复杂但是还可以简化，使用 where 关键字进行简化：

fn some_function<T, U>(t: &T, u: &U) -> i32
    where T: Display + Clone,
          U: Clone + Debug
{}

函数返回中的 impl Trait

可以通过 impl Trait 来说明一个函数返回了一个类型，该类型实现了某个特征:

fn returns_summarizable() -> impl Summary {
    Weibo {
        username: String::from("linus"),
        content: String::from(
            "fuck you,nvidia!",
        )
    }
}

但是这种返回值方式有一个很大的限制：只能有一个具体的类型。如果返回不同的类型，编译器就会报错。

其他获取特征的方法

• 通过 derive 派生特征，如 #[derive(Debug)], Debug 有一套自动实现的默认代码，当你给一个结构体标记后，就可以使用 println!(“{:?}”, s) 的形式打印该结构体的对象。
• 调用方法需要引入特征，如： use std::convert::TryInto;。 如果你要使用一个特征的方法，那么你需要将该特征引入当前的作用域中, 如：try_into 就需要引入 std::convert::TryInto 特征。

实际应用

给定一个数组，需要找出其中的最大值：

fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

代码解释：PartialOrd 位于 prelude，因此使用的时候不需要手动导入，它要求可以比较的类型，Copy 是要求比较的类型要实现了 Copy 特性，这样才能将所有权转移，如果不加 Copy 则会报错：cannot move out of type [T], a non-copy slice，Copy 特征还是可以使用 Clone 特征，最后运行的结果如下：

特征对象

由于 impl Trait 的返回值类型不支持多种不同类型返回，所以 Rust 引入了特征对象。特征对象，简单理解就是把实现了某一个特征的类型的实例，存储在数组中，在调用时通过调度找到具体的类型方法。可以通过 & 引用或者 Box 智能指针的方式来创建特征对象。 看例子：为多个类型实现 Draw 特征

// 定义 Draw 特征
trait Draw {
    fn draw(&self) -> String;
}

// 为 u8 类型实现 Draw 特征
impl Draw for u8 {
    fn draw(&self) -> String {
        format!("u8 is {}", *self)
    }
}

// 为 f64 类型实现 Draw 特征
impl Draw for f64 {
    fn draw(&self) -> String {
        format!("f64 is {}", *self)
    }
}

// 创建特征对象，
// 若 T 实现了 Draw 特征， 则调用该函数时传入的 Box<T> 可以被隐式转换成函数参数签名中的 Box<dyn Draw>
fn draw1(x: Box<dyn Draw>) {
    // Box 智能指针会自动解引用为它所包裹的值，然后调用该值对应的类型上定义的 `draw` 方法
    x.draw();
}

fn draw2(x: &dyn Draw){
    // 这可以理解为调用不同类型的 Draw 方法
    println!("{:?}", x.draw())
}

fn main() {
    let x = 1.1f64;
    let y = 8u8;
    // 基于 x 的值创建一个 Box<f64> 类型的智能指针，指针指向的数据被放置在了堆上
    draw1(Box::new(x));
    // 基于 x 的值创建一个 Box<u8> 类型的智能指针，指针指向的数据被放置在了堆上
    draw1(Box::new(y));
    draw2(&x);
    draw2(&y);
}

有几点注意：

• draw1 函数的参数是 Box 形式的特征对象，该特征对象是通过 Box::new(x) 的方式创建的
• draw2 函数的参数是 &dyn Draw 形式的特征对象，该特征对象是通过 &x 的方式创建的
• dyn 关键字只用在特征对象的类型声明上，在创建时无需使用 dyn

可以使用特征对象来代表泛型或具体的类型

特征对象的动态分发

编译器会在编译期为每一个泛型参数对应的具体类型生成一份儿代码，这中分发方式称为静态分发。而动态分发是在运行时才能确定需要调用什么方法的，因此关键字 dyn 强调的就是动态。

当使用特征对象时，Rust 必须使用动态分发。编译器无法知晓所有可能用于特征对象代码的类型，所以它也不知道应该调用哪个类型的哪个方法实现。为此，Rust 在运行时使用特征对象中的指针来知晓需要调用哪个方法。动态分发也阻止编译器有选择的内联方法代码，这会相应的禁用一些优化。

具体可以看这个图：

Self 与 self

有两个self， self 一个指代当前的实例对象，Self 一个指代特征或者方法类型的别名,如：

trait Draw {
    fn draw(&self) -> Self;
}

#[derive(Clone)]
struct Button;
impl Draw for Button {
    fn draw(&self) -> Self {
        return self.clone()
    }
}

fn main() {
    let button = Button;
    let newb = button.draw();
}

在这里，self 指代的是当前的实例对象，也就是 button 实例，而 Self 指的是 Button 类型。

特征对象的限制

• 方法的返回类型不能是 Self
• 方法没有任何泛型参数

集合类型

集合在 Rust 中是一类比较特殊的类型，因为 Rust 中大多数数据类型都只能代表一个特定的值，但是集合却可以代表一大堆值。而且与语言级别的数组、字符串类型不同，标准库里的这些家伙是分配在堆上，因此都可以进行动态的增加和减少。在标准库中最常用的集合类型就是：Vector,HashMap 以及 String。

动态数组

动态数组类型用 Vec 表示，动态数组允许你存储多个值，动态数组只能存储相同类型的元素。

创建动态数组

创建动态数组有两种方式，方式一：

// 使用 Vec::new 创建动态数组是最 rusty 的方式
let mut v = Vec::new();
v.push(1);

方式二：

// 使用宏 vec! 来创建数组，在这里无需标注数据类型，编译器会自动推倒出 v 的类型。
let v = vec![1, 2, 3];

更新

向数组尾部添加元素，可以使用 push 方法：

let mut v = Vec::new();
v.push(1);

注意：声明为 mut 后，才能进行修改。Vector 类型在超出作用域范围后，会被自动删除，其中的元素也会被删除

读取

let v = vec![1, 2, 3, 4, 5];

let third: &i32 = &v[2];
// 使用下标方法
println!("第三个元素是 {}", third);
// 使用 get 方法
match v.get(2) {
    Some(third) => println!("第三个元素是 {third}"),
    None => println!("去你的第三个元素，根本没有！"),
}

Vector 有两种获取元素的方式：下标和get，二者的区别在下标在越界访问时会退出，而 get 则不会。

一些常用的方法

方法	说明
new()	创建一个空的向量的实例
push()	将某个值 T 添加到向量的末尾
remove()	删除并返回指定的下标元素
contains()	判断向量是否包含某个值
len()	返回向量中的元素个数

遍历数组

用下标的方式去遍历数组更安全也更高效，每次下标访问都会触发数组边界检查。

let v = vec![1, 2, 3];
for i in &v {
    println!("{i}");
}

遍历时修改元素

let mut v = vec![1, 2, 3];
for i in &mut v {
    *i += 10
}

存储不同类型的元素

由于 Vector 只能存储同类型的元素，但是可以使用枚举和特征对象实现存储不同类型的目的，首先是枚举类型：

#[derive(Debug)]
enum IpAddr {
    V4(String),
    V6(String)
}
fn main() {
    let v = vec![
        IpAddr::V4("127.0.0.1".to_string()),
        IpAddr::V6("::1".to_string())
    ];

    for ip in v {
        show_addr(ip)
    }
}

fn show_addr(ip: IpAddr) {
    println!("{:?}",ip);
}

再特征对象的实现

trait IpAddr {
    fn display(&self);
}

struct V4(String);
impl IpAddr for V4 {
    fn display(&self) {
        println!("ipv4: {:?}",self.0)
    }
}
struct V6(String);
impl IpAddr for V6 {
    fn display(&self) {
        println!("ipv6: {:?}",self.0)
    }
}

fn main() {
    let v: Vec<Box<dyn IpAddr>> = vec![
        Box::new(V4("127.0.0.1".to_string())),
        Box::new(V6("::1".to_string())),
    ];

    for ip in v {
        ip.display();
    }
}

同时借用多个数组元素

当遇到借用多个数组元素的情况时需要注意，不能同时存在不可变借用和可变借用，如：

let mut v = vec![1, 2, 3, 4, 5];

let first = &v[0];

v.push(6);

println!("The first element is: {first}");

数组的大小是可变的，当旧数组的大小不够用时，Rust 会重新分配一块更大的内存空间，然后把旧数组拷贝过来。这种情况下，之前的引用显然会指向一块无效的内存。

HashMap

HashMap 也是 Rust 标准库中提供的集合类型，但是又与动态数组不同，HashMap 中存储的是一一映射的 KV 键值对，并提供了平均复杂度为 O(1) 的查询方法，当我们希望通过一个 Key 去查询值时，该类型非常有用。Rust 中哈希类型（哈希映射）为 HashMap<K,V>，在其它语言中，也有类似的数据结构，例如 hash map，map，object，hash table，字典等等。

创建 HashMap

使用 new 创建

use std::collections::HashMap;
let mut my_vul = HashMap::new();
// 漏洞类型对应的数量
my_vul.insert("RCE", 1);
my_vul.insert("XSS", 10);
my_vul.insert("SQL", 199);

使用迭代器和 collect 方法创建

use std::collections::HashMap;

fn main() {
    let teams_list = vec![
        ("中国队".to_string(), 100),
        ("美国队".to_string(), 10),
        ("日本队".to_string(), 50),
    ];

    let mut teams_map = HashMap::new();
    for team in &teams_list {
        teams_map.insert(&team.0, team.1);
    }

    println!("{:?}",teams_map)
}

先将 Vec 转为迭代器，接着通过 collect 方法，将迭代器中的元素收集后，转成 HashMap

use std::collections::HashMap;
fn main() {
    let teams_list = vec![
        ("中国队".to_string(), 100),
        ("美国队".to_string(), 10),
        ("日本队".to_string(), 50),
    ];

    let teams_map: HashMap<_,_> = teams_list.into_iter().collect();
    
    println!("{:?}",teams_map)
}

所有权转移

HashMap 的所有权规则与其它 Rust 类型没有区别：

• 若类型实现 Copy 特征，该类型会被复制进 HashMap，因此无所谓所有权
• 若没实现 Copy 特征，所有权将被转移给 HashMap 中

  use std::collections::HashMap;
  
  fn main() {
  
      let name = String::from("Sunface");
      let age = 18;
  
      let mut handsome_boys = HashMap::new();
      handsome_boys.insert(&name, age);
  
      println!("因为过于无耻，{:?}已经被除名", handsome_boys);
      println!("还有，他的真实年龄远远不止{}岁", age);
  }

  如果你使用引用类型放入 HashMap 中，请确保该引用的生命周期至少与 HashMap 的生命周期一致。

查询

HashMap 通过 get 方法获取元素，如：

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

let team_name = String::from("Blue");
let score: Option<&i32> = scores.get(&team_name);

注意：

• get 方法返回一个 Option<&i32> 类型：当查询不到时，会返回一个 None，查询到时返回 Some(&i32)
• &i32 是对 HashMap 中值的借用，如果不使用借用，可能会发生所有权的转移

更新

HashMap 的更新存在多种情况

fn main() {
    use std::collections::HashMap;

    let mut scores = HashMap::new();

    scores.insert("Blue", 10);

    // 覆盖已有的值
    let old = scores.insert("Blue", 20);
    assert_eq!(old, Some(10));

    // 查询新插入的值
    let new = scores.get("Blue");
    assert_eq!(new, Some(&20));

    // 查询Yellow对应的值，若不存在则插入新值
    let v = scores.entry("Yellow").or_insert(5);
    assert_eq!(*v, 5); // 不存在，插入5

    // 查询Yellow对应的值，若不存在则插入新值
    let v = scores.entry("Yellow").or_insert(50);
    assert_eq!(*v, 5); // 已经存在，因此50没有插入
}

Ref

Rust语言圣经(Rust Course)