rust泛型类型与关联类型

July 29, 2022

此篇是关于泛型类型和关联类型实现 trait 上面的区别

关联类型

关联类型允许在实现 trait 时再指定具体类型，而不是在 trait 定义时决定。

此处定义的 Add 非 std::ops::Add，后者是实现运算符重载的 trait

rust

trait Add {
    type OtherOne; // 这个类型需要实现者指定
    fn add(&self, other: Self::OtherOne) -> Self; // 使用 Self::OtherOne 而不是 OtherOne
}

#[derive(Debug)]
struct Int(i32);

impl Add for Int {
    type OtherOne = i32; // 实现者指定具体类型
    fn add(&self, other: Self::OtherOne) -> Self {
        Int(self.0 + other)
    }
}

fn main() {
    let i = Int(1);
    let sum = i.add(2);
    println!("{:?}", sum); // -> Int(3)
}

关联类型一旦实现，该 trait 中的函数签名就已经确定，无法再实现关于令一个类型的同 trait 函数
在需要实现同名 trait 函数并允许使用多个不同类型时，则采用泛型类型

关联类型只能实现一次，泛型类型可以实现多次

在尖括号进行关联

可以在尖括号内部通过：type名 = 实际类型 直接进行类型关联
不过，虽然使用了尖括号语法，但这里并不是泛型，而是关联类型
例如：

rust

fn example1(i: impl Add<OtherOne = i32> + std::fmt::Debug, j: i32) {
    let out = i.add(j);
    println!("{:?}", out);
}

fn example2<T>(i: T, j: i32)
where
    T: Add<OtherOne = i32> + std::fmt::Debug,
{
    let out = i.add(j);
    println!("{:?}", out);
}

fn main() {
    example1(Int(1), 2); // -> Int(3)
    example2(Int(1), 2); // -> Int(3)
}

泛型类型

rust

trait Add<T> {
    fn add(&self, other: T) -> Self;
}

#[derive(Debug)]
struct Int(i32);

impl Add<&i32> for Int {
    // 在这里，实现了泛型的某一具体类型，但也可以同时实现多个类型
    fn add(&self, other: &i32) -> Self {
        Int(self.0 + *other)
    }
}

fn main() {
    let i = Int(1);
    let j = 2;
    let sum = i.add(&j);
    println!("{:?}+{}={:?}", i, j, sum); // -> Int(1)+2=Int(3)
}

默认类型参数

目前，rust 在除泛型函数之外，可以给泛型参数指定默认泛型类型
例如：

rust

#[derive(Debug)]
struct Int(i32);

trait Same<T = Int> {
    fn same(x: T) -> T {
        x
    }
}

impl Same for Int {}

fn main() {
    let x = Int(8);
    println!("{:?}", Int::same(x)); // => Int(8)
}

结合使用

实际上，二者是不冲突的。
例如，标准库提供的 std::ops::Add trait

rust

// RHS = right hand side
trait Add<RHS=Self> {
    type Output;
    fn add(self, rhs: RHS) -> Self::Output;
}

←Back to home