在软件开发中，经常需要编写能够处理多种数据类型的代码。传统的做法是复制代码并修改类型，或者使用不安全的类型转换。泛型（Generics）提供了一种类型安全的方式来编写可重用的代码，让同一段代码能够处理不同的数据类型。

Rust的泛型系统不仅强大，而且零成本——泛型代码在编译时会被单态化（Monomorphization），生成针对具体类型的优化代码，运行时没有任何性能损失。

函数中的泛型

基本语法

fn largest<T>(list: &[T]) -> &T 
where
    T: PartialOrd,
{
    let mut largest = &list[0];
    
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    
    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];
    let result = largest(&number_list);
    println!("The largest number is {}", result);
    
    let char_list = vec!['y', 'm', 'a', 'q'];
    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

多个泛型参数

fn mix<T, U>(a: T, b: U) -> (T, U) {
    (a, b)
}

fn main() {
    let mixed = mix(1, "hello");
    println!("{:?}", mixed); // (1, "hello")
}

结构体中的泛型

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

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

// 为特定类型实现方法
impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
    
    println!("integer.x = {}", integer.x());
    println!("float distance = {}", float.distance_from_origin());
}

多个泛型参数的结构体

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

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,
        }
    }
}

fn main() {
    let p1 = Point { x: 5, y: 10.4 };
    let p2 = Point { x: "Hello", y: 'c' };
    
    let p3 = p1.mixup(p2);
    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}

枚举中的泛型

enum Option<T> {
    Some(T),
    None,
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}

// 自定义泛型枚举
enum Container<T> {
    Empty,
    Single(T),
    Pair(T, T),
    Many(Vec<T>),
}

impl<T> Container<T> {
    fn is_empty(&self) -> bool {
        matches!(self, Container::Empty)
    }
    
    fn len(&self) -> usize {
        match self {
            Container::Empty => 0,
            Container::Single(_) => 1,
            Container::Pair(_, _) => 2,
            Container::Many(vec) => vec.len(),
        }
    }
}

方法中的泛型

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

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

// 只为实现了特定trait的类型实现方法
impl<T: Display + PartialOrd> Pair<T> {
    fn cmp_display(&self) {
        if self.x >= self.y {
            println!("The largest member is x = {}", self.x);
        } else {
            println!("The largest member is y = {}", self.y);
        }
    }
}

泛型与trait约束

where子句

use std::fmt::Display;

fn some_function<T, U>(t: T, u: U) -> i32
where
    T: Display + Clone,
    U: Clone + Debug,
{
    // 函数体
    0
}

多个trait约束

use std::fmt::Display;
use std::fmt::Debug;

fn compare_and_print<T, U>(t: T, u: U)
where
    T: Display + Clone,
    U: Display + Clone,
{
    println!("t: {}, u: {}", t, u);
}

泛型的实际应用

数据结构实现

struct Stack<T> {
    items: Vec<T>,
}

impl<T> Stack<T> {
    fn new() -> Self {
        Self {
            items: Vec::new(),
        }
    }
    
    fn push(&mut self, item: T) {
        self.items.push(item);
    }
    
    fn pop(&mut self) -> Option<T> {
        self.items.pop()
    }
    
    fn peek(&self) -> Option<&T> {
        self.items.last()
    }
    
    fn is_empty(&self) -> bool {
        self.items.is_empty()
    }
    
    fn len(&self) -> usize {
        self.items.len()
    }
}

fn main() {
    let mut stack = Stack::new();
    stack.push(1);
    stack.push(2);
    stack.push(3);
    
    while let Some(value) = stack.pop() {
        println!("Popped: {}", value);
    }
}

算法实现

fn binary_search<T>(arr: &[T], target: &T) -> Option<usize>
where
    T: Ord,
{
    let mut left = 0;
    let mut right = arr.len();
    
    while left < right {
        let mid = left + (right - left) / 2;
        match arr[mid].cmp(target) {
            std::cmp::Ordering::Equal => return Some(mid),
            std::cmp::Ordering::Less => left = mid + 1,
            std::cmp::Ordering::Greater => right = mid,
        }
    }
    
    None
}

fn main() {
    let numbers = vec![1, 3, 5, 7, 9, 11, 13, 15];
    let result = binary_search(&numbers, &7);
    println!("Found 7 at index: {:?}", result);
    
    let words = vec!["apple", "banana", "cherry", "date"];
    let result = binary_search(&words, &"cherry");
    println!("Found 'cherry' at index: {:?}", result);
}

缓存系统

use std::collections::HashMap;
use std::hash::Hash;

struct Cache<K, V> {
    data: HashMap<K, V>,
    max_size: usize,
}

impl<K, V> Cache<K, V>
where
    K: Hash + Eq + Clone,
{
    fn new(max_size: usize) -> Self {
        Self {
            data: HashMap::new(),
            max_size,
        }
    }
    
    fn get(&self, key: &K) -> Option<&V> {
        self.data.get(key)
    }
    
    fn insert(&mut self, key: K, value: V) {
        if self.data.len() >= self.max_size {
            // 简单的LRU实现：删除第一个元素
            if let Some(first_key) = self.data.keys().next().cloned() {
                self.data.remove(&first_key);
            }
        }
        self.data.insert(key, value);
    }
    
    fn clear(&mut self) {
        self.data.clear();
    }
    
    fn len(&self) -> usize {
        self.data.len()
    }
}

泛型与生命周期

use std::fmt::Display;

fn longest_with_an_announcement<'a, T>(
    x: &'a str,
    y: &'a str,
    ann: T,
) -> &'a str
where
    T: Display,
{
    println!("Announcement! {}", ann);
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";
    
    let result = longest_with_an_announcement(
        string1.as_str(),
        string2,
        "Today is someone's birthday!",
    );
    println!("The longest string is {}", result);
}

高级泛型技巧

1. 关联类型

trait Iterator {
    type Item;  // 关联类型
    
    fn next(&mut self) -> Option<Self::Item>;
}

struct Counter {
    count: u32,
}

impl Iterator for Counter {
    type Item = u32;
    
    fn next(&mut self) -> Option<Self::Item> {
        self.count += 1;
        if self.count < 6 {
            Some(self.count)
        } else {
            None
        }
    }
}

2. 泛型trait实现

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

#[derive(Debug, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Point;
    
    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

impl Add<i32> for Point {
    type Output = Point;
    
    fn add(self, rhs: i32) -> Point {
        Point {
            x: self.x + rhs,
            y: self.y + rhs,
        }
    }
}

3. 类型级别的编程

trait TypeLevel {
    type Output;
}

struct AddOne;
struct AddTwo;

impl TypeLevel for AddOne {
    type Output = AddTwo;
}

impl TypeLevel for AddTwo {
    type Output = AddOne; // 循环，实际应用中会更复杂
}

// 使用类型级别的计算
fn process<T: TypeLevel>(input: T) -> T::Output {
    // 编译时计算
    todo!()
}

性能优化

Rust的泛型通过单态化实现零成本抽象：

// 泛型函数
fn generic_function<T>(x: T) -> T {
    x
}

// 编译器会生成类似这样的具体实现：
fn generic_function_i32(x: i32) -> i32 {
    x
}

fn generic_function_string(x: String) -> String {
    x
}

常见陷阱与最佳实践

1. 避免过度泛型化

// 不好的做法：不必要的泛型
fn bad_function<T>(x: T) -> T 
where
    T: Clone,
{
    x.clone()
}

// 好的做法：直接使用具体类型
fn good_function(x: String) -> String {
    x
}

2. 合理使用trait约束

// 不好的做法：过于宽泛的约束
fn bad_function<T>(x: T) -> String 
where
    T: ToString,
{
    x.to_string()
}

// 好的做法：精确的约束
fn good_function<T>(x: T) -> String 
where
    T: Display,
{
    format!("{}", x)
}

3. 考虑编译时间

// 大量泛型可能导致编译时间增长
// 在性能关键路径上使用具体类型
fn performance_critical_function(x: i32) -> i32 {
    x * 2  // 编译时优化
}

写在最后

Rust的泛型系统提供了：

• 类型安全：编译时检查类型正确性
• 零成本抽象：运行时没有性能损失
• 代码复用：同一段代码处理多种类型
• 表达力强：能够表达复杂的类型关系

泛型不是银弹，但它是编写可维护、高性能代码的重要工具。通过合理使用泛型，可以写出既灵活又安全的代码，让类型系统成为助手而不是障碍。