rust泛型和特征

为什么需要泛型

• 更有表达力
• 编写代码时需要更多的思考和构造

rust的泛型和其他语言类似，常用的几种场景，可以在代码里面看到

• 方法泛型
• struct泛型
• 泛型struct的方法实现

使用特征扩展类型。特征和java8之后的接口很像啊

• 类似java的接口
• 支持关联方法，实现方法
• 支持继承

特征的分类，主要是指特征的使用场景

• 空方法的标记特征，类似空的注解
• 简单特征，泛型特征，关联特征，继承特征

特征区间，通过特征确定方法或者类的范围

• 支持区间
• 泛型函数和impl代码的特征区间
• where

标准库特征

• Debug
• PartialEq和Eq
• Copy和Clone

泛型的实现

• 静态分发，编译时决定调用
• 动态分发，运行时决定，通过续表的接口列表去查找对应的类，额外的资源开销

rust支持动态分发

• 特征对象，实现为胖指针，变量后面加上&
• rust的动态对象 &dyn，通常用的比较少

代码语言：rust复制

use std::fmt::Debug;

fn test1<T>(value:T) {
    let _ = value;
}


enum Tsss<T> {
    Signal(T),
    Nosignal
}


struct GenericS2<T>{
    item:T
}

impl<T> GenericS2<T> {
    fn newGenericS2(i :T) -> Self {
        GenericS2{item:i}
    }
}

impl GenericS2<u32> {
    fn newGenericS2Int(i :u32) -> Self {
        GenericS2{item:i}
    }
}

trait Playable {
    fn play(&self);
    fn pause() {
        println!("Paused");
    }
}

struct Audio(String);
struct Video(String);
impl Playable for Audio {
    fn play(&self){
        println!("audio {}", self.0)
    }
}

impl Playable for Video {
    fn play(&self){
        println!("video {}", self.0)
    }
}

struct A;
struct B;
struct C;

trait InitA{
    fn init(&self);
}
impl InitA for A{
    fn init(&self){
        println!("init a");
    }
}

impl InitA for B{
    fn init(&self){
        println!("init b");
    }
}

impl C {
    fn ainit<T: InitA>(&self, s:T) {
        s.init();
    }
}

trait A1{
    fn a1(&self) {
        println!("a1")
    }
}

trait A2{
    fn a2(&self) {
        println!("a2")
    }
}
trait A3{
    fn a3(&self) {
        println!("a3")
    }
}

trait A4 : A1 A2 A3{
    fn a4(&self) {
        self.a1();
        self.a2();
        self.a3();
        println!("repeat!")
    }
}

struct Bb;
impl A1 for Bb{}
impl A2 for Bb{}
impl A3 for Bb{}
impl A4 for Bb{}

trait Entable {
    fn eat(&self);
}
#[derive(Debug)]
struct Food<T>(T);
#[derive(Debug)]
struct Apple;
impl<T> Entable for Food<T> where T:Debug {
    fn eat(&self) {
        println!("eater {:?}", self);
    }
}

fn eat<T>(val:T) where T:Entable {
    val.eat();
}



fn main() {

    let apple = Food(Apple);
    eat(apple);


    println!("Hello, world!");
    test1(12);
    test1("a");

    let s2 = GenericS2::newGenericS2(123);

    let mut vec1:Vec<u8> = Vec::new();
    vec1.push(1);

    let video1 = Audio("abc".to_string());
    video1.play();

    let cx = C;
    cx.ainit(A);
    cx.ainit(B);


    Bb.a4();

}

rustrust

0 人点赞