RUST 入门（3）泛型

泛型是具体类型或者其他属性的抽象替代，用于减少代码重复。

在函数中使用

示例 求最大值 [i32] 和 [char]

fn main() {
    let number_list = vec![1,2,3,4,5,6,100,8,9];
    let max_number=largest_i32(&number_list);
    println!("最大的数字是{}",max_number);

    let char_list=vec!['x','a','c','v'];
    let max_char=largest_char(&char_list);
    println!("最大的字符是{}",max_char);

    let largest1=largest(&number_list);
    let largest2=largest(&char_list);
    println!("largest1 是{largest1} largest2 是{largest2}");
}
fn largest_i32(list:&[i32] )->i32{
    let mut largest=list[0];
    for &item in list.iter(){
        if item >largest{
            largest=item;
        }
    }
    largest
}
fn largest_char(list:&[char] )->char{
    let mut largest=list[0];
    for &item in list.iter(){
        if item >largest{
            largest=item;
        }
    }
    largest
}
//使用泛型
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 integer = Point{x:5,y:6};
    let floate=Point{x:1.1,y:1.2};
    println!("{:#?}",integer);
    println!("{:?}",floate);
    let test = Point2{x:'A',y:100};
    println!("{:?}",test);
}
#[derive(Debug)]
struct  Point<T>{
    x:T,
    y:T
}
#[derive(Debug)]
struct  Point2<T,U>{
    x:T,
    y:U
}

在 函数 中使用泛型

fn main() {
     let p1=Point{x:1,y:'a'};
     let p2=Point{x:"你好",y:2.99};

     let p3 = p1.create_mix_point(&p2);
     println!("p3.x={},p3.y={}",p3.get_x(),p3.get_y());

     let p4 =p2.create_mix_point(&p1);
     println!("p4.x={},p4.y={}",p4.get_x(),p4.get_y());
}

struct Point<A:Copy,B:Copy>
{
x:A,
y:B,
}
impl<A:Copy,B:Copy> Point<A,B> {
    fn get_x(&self)->&A{
        &self.x
    }
    fn get_y(&self)->&B{
        &self.y
    }
    fn create_mix_point<C:Copy,D:Copy>(&self,other:&Point<C,D>)->Point<A,D>{
        Point{
            x: self.x,
            y:other.y
        }
    }
}

 

 

泛型 Option<T> 被编译器替换为了具体的定义。因为 Rust 会将每种情况下的泛型代码编译为具体类型，使用泛型没有运行时开销。当代码运行时，它的执行效率就跟好像手写每个具体定义的重复代码一样。这个单态化过程正是 Rust 泛型在运行时极其高效的原因。

上面这段话我不知道什么意思，但我大为震撼！0.0