详解Rust泛型用法-EW帮帮网

微信交流群：https://732903.hlcode.cn/?id=NK1fWUR

文章目录

Rust是一种系统编程语言，它拥有强大的泛型支持，泛型是Rust中用于实现代码复用和类型安全的重要特性。通过泛型程序员可以编写能够操作不同类型数据的函数、结构体、枚举和方法，同时又能确保类型安全，避免类型错误。在Rust中泛型的使用不仅能够提升代码的复用性，还能使得代码更加灵活，尤其是在实现与数据类型无关的算法时。

泛型的关键特点:
1.通过类型占位符(如 T)使得代码能够与多种类型一起工作。
2.Rust会在编译时检查类型，保证类型一致性。
3.通过泛型，我们可以在不牺牲类型安全的前提下编写通用代码。

基础语法

Rust泛型的基础语法是使用尖括号<>来指定类型的占位符。

fn print_value<T>(value: T) {
    println!("{:?}", value);
}

fn main() {
    print_value(42);           // T 由 i32 类型替代
    print_value("Hello, Rust!"); // T 由 &str 类型替代
}

在上面的代码中print_value函数接受一个类型为T的参数value并打印它的值。这里T是一个泛型类型，在main函数中分别传入了i32和&str类型。

泛型与结构体

Rust中的结构体也可以使用泛型，这使得我们能够定义更加通用的容器结构体。泛型结构体允许我们在实例化时为结构体的字段指定具体的类型。

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

impl<T> Point<T> {
    fn new(x: T, y: T) -> Self {
        Point { x, y }
    }

    fn get_x(&self) -> &T {
        &self.x
    }

    fn get_y(&self) -> &T {
        &self.y
    }
}

fn main() {
    let p1 = Point::new(1, 2);     //T由i32类型替代
    let p2 = Point::new(1.1, 2.2); //T由f64类型替代

    println!("p1: ({}, {})", p1.get_x(), p1.get_y());
    println!("p2: ({}, {})", p2.get_x(), p2.get_y());
}

//两个参数可以类型不同  
struct Point<T,U> {
    x: T,
    y: U,
}
fn main() {
    let p = Point{x: 1, y :1.1};
}

泛型约束

泛型本身并不限制类型的行为，但在某些情况下我们希望限制泛型类型的行为或特性。为此Rust引入了泛型约束(Traits)。通过where关键字或者impl块中的trait约束，可以确保泛型类型实现了某些特定的行为。

use std::fmt::Debug;

fn print_debug<T: Debug>(value: T) {
    println!("{:?}", value);
}

fn main() {
    print_debug(42);             //适用于实现了Debug的i32类型
    print_debug("Hello, Rust!"); //适用于实现了Debug的&str类型
}

除了在函数签名中使用T: Trait语法外，Rust还允许通过where语法进行更复杂的泛型约束。

fn print_debug<T>(value: T)
where
    T: Debug,
{
    println!("{:?}", value);
}

泛型与生命周期

Rust的生命周期(lifetimes)和泛型是密切相关的。为了保证内存安全，Rust强制要求你显式标注引用类型的生命周期。这使得在处理泛型类型时，生命周期标注变得尤为重要。生命周期的内容在后面的文章中会详细介绍，这里就不细说了。

//生命周期 'a 确保了返回的引用在两个输入字符串的生命周期内有效
fn longest<'a, T>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

fn main() {
    let string1 = String::from("long string");
    let string2 = String::from("short");
    let result = longest(&string1, &string2);
    println!("The longest string is: {}", result);
}

泛型与枚举

Rust的枚举也可以使用泛型，这使得我们可以定义更灵活和强大的枚举类型。比如，Option 和 Result<T, E> 就是标准库中的泛型枚举类型。

//Option 用于值的存在与否不同，Result 关注的主要是值的正确性   
enum Option<T> {
    Some(T),
    None,
}
enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn main() {
    let some_value = Option::Some(42);
    let none_value: Option<i32> = Option::None;
    
    match some_value {
        Option::Some(value) => println!("Some value: {}", value),
        Option::None => println!("No value"),
    }
}

泛型和Vec

Rust标准库中的Vec就是一个泛型集合类型，允许我们存储任意类型的元素。

fn main() {
    let mut numbers: Vec<i32> = Vec::new();
    numbers.push(1);
    numbers.push(2);
    numbers.push(3);

    for number in numbers {
        println!("{}", number);
    }
}

静态泛型(const 泛型)

Rust1.51版本引入了const泛型，使得你可以在编译时为泛型类型提供常量值。这通常用于数组大小、结构体字段或其他与常量相关的场景。通过const泛型，类型不仅限于具体的类型，也可以是编译时常量。

//在ArrayWrapper结构体中N代表数组的大小 而T则代表元素的类型。
struct ArrayWrapper<T, const N: usize> {
    data: [T; N],
}

impl<T, const N: usize> ArrayWrapper<T, N> {
    fn new(data: [T; N]) -> Self {
        ArrayWrapper { data }
    }

    fn print(&self) {
        for item in &self.data {
            println!("{:?}", item);
        }
    }
}

fn main() {
    let arr = ArrayWrapper::<i32, 5>::new([1, 2, 3, 4, 5]);
    arr.print();
}

//泛型T必须支持Debug特性  
//N这个泛型参数，它是一个基于值的泛型参数  任何长度的数组都可以传入  
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);
}

这种方式使得Rust在编译时就能够推断出类型和常量大小，从而实现编译时的类型安全和高效性。

类型别名

Rust允许使用type关键字来创建类型别名，特别是当泛型类型变得过于复杂或冗长时。

type StringResult = Result<String, std::io::Error>;

fn get_file_content() -> StringResult {
    // 假设这是一个读取文件的函数，返回的是一个包含内容或错误的结果
    Ok("Hello, file!".to_string())
}

fn main() {
    match get_file_content() {
        Ok(content) => println!("{}", content),
        Err(e) => println!("Error: {}", e),
    }
}

默认类型参数

Rust中的泛型不仅可以是任意类型，也可以为泛型参数提供默认值。使用默认值可以减少函数或结构体定义中的样板代码，并使得用户在调用时不必每次都显式提供类型。

struct Wrapper<T = i32> {
    value: T,
}

impl<T> Wrapper<T> {
    fn new(value: T) -> Self {
        Wrapper { value }
    }
}

fn main() {
    let default_wrapper = Wrapper::new(42);  //T默认为 i32
    let string_wrapper = Wrapper::new(String::from("Hello")); //使用 String 类型
    println!("{}", default_wrapper.value);
    println!("{}", string_wrapper.value);
}

Sized Trait与泛型

Rust中的类型有一个特殊的trait叫 Sized，它表示一个类型的大小在编译时是已知的。绝大多数类型都实现了Sized trait，但也有一些例外(例如动态大小类型DST，如 str、[T]等）。在泛型中Sized trait很常见，通常它会隐式地应用于泛型参数。

//T: Sized限制了T必须是一个已知大小的类型  
fn print_size<T: Sized>(value: T) {
    println!("Size of value: {}", std::mem::size_of::<T>());
}

fn main() {
    let x = 42;
    print_size(x);
}

//例如str就是一个DST，如果想要在泛型函数中接受动态大小类型可以通过 ?Sized 来消除 Sized 限制
fn print_size<T: ?Sized>(value: &T) {
    // 允许接受动态大小类型
    println!("Size of value: {}", std::mem::size_of_val(value));
}

fn main() {
    let s: &str = "hello";
    print_size(s);
}

常量函数与泛型

const fn即常量函数。const fn允许我们在编译期对函数进行求值。在编译期就计算出一些值，以提高运行时的性能或满足某些编译期的约束条件提高运行时的性能，还使代码更加简洁和安全。

const fn add(a: usize, b: usize) -> usize {
    a + b
}
const RESULT: usize = add(5, 10);
fn main() {
    println!("The result is: {}", RESULT);
}


//const fn 与 const 泛型相结合  
struct Buffer<const N: usize> {
    data: [u8; N],
}

const fn compute_buffer_size(factor: usize) -> usize {
    factor * 1024
}

fn main() {
    const SIZE: usize = compute_buffer_size(4);
    let buffer = Buffer::<SIZE> {
        data: [0; SIZE],
    };
    println!("Buffer size: {} bytes", buffer.data.len());
}

泛型的性能

Rust中的泛型在编译时通过 monomorphization(单态化)机制进行优化。即每当一个泛型函数或结构体被实例化时，Rust会根据具体的类型生成专门的代码，从而避免了运行时的性能开销。因此Rust的泛型在运行时与手写的非泛型代码几乎没有区别，提供了与静态类型语言一样的性能。

详解Rust泛型用法