Rust泛型与特性

时间：2025-04-20 07:36:03

文章目录

    • 泛型
      • 函数中的泛型
      • 结构体与枚举中的泛型
      • 特性（trait）
      • 默认特性
        • Trait作为参数
        • 特性做返回值
    • 给结构体实现方法

泛型

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

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) -> i32
    where 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之后才能实现

相关文章