在 Rust 中，泛型（Generics）和特性（Trait）是实现代码抽象、复用和多态的核心机制。它们允许我们编写灵活且类型安全的代码，同时避免冗余。本教程将详细介绍这些概念及其实际应用。

一、泛型（Generics）基础

泛型是一种参数化类型的机制，允许我们定义不特定于某一类型的函数、结构体或枚举，从而提高代码复用性。

1. 泛型函数

泛型函数使用类型参数（通常用<T>表示）来定义可以处理多种类型的函数。

fn swap<T: Copy>(a: &mut T, b: &mut T) {
    let temp = *a;  
    *a = *b;
    *b = temp;
}

fn main() {
    let mut x = 5;
    let mut y = 10;
    swap(&mut x, &mut y);
    println!("x = {}, y = {}", x, y); // 输出: x = 10, y = 5

    let mut s1 = String::from("hello");
    let mut s2 = String::from("world");
    // 注意：String没有实现Copy特性，所以下面这行会报错
    // swap(&mut s1, &mut s2);
    // println!("s1 = {}, s2 = {}", s1, s2);
}

类型参数T可以是任何类型，但函数要求两个参数必须是相同类型，保证了类型安全。

2. 泛型结构体

泛型结构体在定义时指定类型参数，使其字段可以是该类型参数的任意实例。

// 泛型结构体：表示二维平面上的点
struct Point<T> {
    x: T,
    y: T,
}

// 为泛型结构体实现方法
impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
    
    fn y(&self) -> &T {
        &self.y
    }
}

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

fn main() {
    let integer_point = Point { x: 5, y: 10 };
    let float_point = Point { x: 3.0, y: 4.0 };
    
    println!("integer x: {}", integer_point.x()); // 输出: integer x: 5
    println!("float distance: {}", float_point.distance_from_origin()); // 输出: float distance: 5
}

3. 泛型枚举

泛型枚举可以包含不同类型的泛型参数，Rust 标准库中的Option和Result就是典型的泛型枚举。

// 自定义泛型枚举：表示可能是A类型或B类型的值
enum Either<A, B> {
    Left(A),
    Right(B),
}

// 为Either实现方法
impl<A, B> Either<A, B> {
    fn is_left(&self) -> bool {
        match self {
            Either::Left(_) => true,
            Either::Right(_) => false,
        }
    }
    
    fn is_right(&self) -> bool {
        !self.is_left()
    }
}

fn main() {
    let num_or_str: Either<i32, String> = Either::Left(42);
    let str_or_bool: Either<String, bool> = Either::Right(true);
    
    println!("Is left: {}", num_or_str.is_left()); // 输出: Is left: true
    println!("Is right: {}", str_or_bool.is_right()); // 输出: Is right: true
}

---

二、特性（Trait）定义、实现和约束

特性（Trait）类似于其他语言中的 "接口"（Interface），用于定义类型必须实现的方法集合。它是 Rust 实现抽象和多态的核心工具。

// 定义一个“可发声”特征（trait）
trait 可发声 {
    // 定义特征方法签名
    fn 发出声音(&self);
}

// 为“狗”结构体实现“可发声”特征
struct 狗;
impl 可发声 for 狗 {
    fn 发出声音(&self) {
        println!("汪汪！");
    }
}

// 为“猫”结构体实现“可发声”特征
struct 猫;
impl 可发声 for 猫 {
    fn 发出声音(&self) {
        println!("喵喵！");
    }
}

// 接收任何实现了“可发声”特征的参数（多态体现）
fn 让动物发声(animal: &impl 可发声) {
    animal.发出声音();
}

fn main() {
    let 小狗 = 狗;
    let 小猫 = 猫;
    让动物发声(&小狗); // 输出“汪汪！”
    让动物发声(&小猫); // 输出“喵喵！”
}

---

三、多特性约束

特性约束用于限制泛型可以接受的类型，确保这些类型实现了特定的特性，从而可以安全地调用特性中的方法。

// 定义一个“可发声”特征（trait）
trait 可发声 {
    // 定义特征方法签名
    fn 发出声音(&self);
}

// 定义一个给宠物“喂食”的特征（trait）
trait 喂食 {
    // 定义特征方法签名
    fn 吃(&self);
}

// 为“狗”结构体实现“可发声”特征
struct 狗;
impl 可发声 for 狗 {
    fn 发出声音(&self) {
        println!("汪汪！");
    }
}
impl 喂食 for 狗 {
    fn 吃(&self) {
        println!("骨头");
    }
}

// 为“猫”结构体实现“可发声”特征
struct 猫;
impl 可发声 for 猫 {
    fn 发出声音(&self) {
        println!("喵喵！");
    }
}
impl 喂食 for 猫 {
    fn 吃(&self) {
        println!("鱼")
    }
}

// 接收任何实现了“可发声+喂食”特征的参数（多态体现）
fn 逗宠物<T:可发声+喂食>(animal: &T){
    animal.发出声音();
    animal.吃();
}

fn main() {
    let 小狗 = 狗;
    let 小猫 = 猫;
    逗宠物(&小狗);
    逗宠物(&小猫);
}

优先使用 where 子句提高可读性

当泛型参数的约束较复杂（如多特性组合、多个泛型参数）时，直接在尖括号中写约束会导致代码冗长难读。此时应使用 where 子句，将约束与泛型参数分离，使逻辑更清晰。

反例（可读性差）：

// 多个约束挤在泛型参数后，难以快速理解
fn complex_function<T: Display + Clone, U: Debug + PartialEq>(a: T, b: U) -> T {
    // ...
    a.clone()
}

正例（使用 where 子句）：

use std::fmt::{Display, Debug};

// where子句单独列出约束，结构更清晰
fn complex_function<T, U>(a: T, b: U) -> T
where
    T: Display + Clone,
    U: Debug + PartialEq,
{
    println!("Display: {}", a);
    a.clone()
}

优势：当泛型参数和约束增多时（如 3 个以上参数），where 子句的可读性优势会更加明显，尤其在结构体、枚举或 trait 定义中。

---

四、derive 派生特质

Rust 提供了derive属性，允许编译器为自定义类型自动实现某些特性。这极大简化了常见特性的实现工作。

常用的可派生特性包括：

• Debug：允许使用{:?}格式化输出
• Clone：允许类型通过clone()方法创建副本
• Copy：允许类型进行隐式复制（而非移动）
• PartialEq/Eq：用于相等性比较
• PartialOrd/Ord：用于排序和比较

// 派生多个特性
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = p1; // 由于实现了Copy，可以直接复制而非移动
    
    // 由于实现了Debug，可以使用{:?}打印
    println!("p1: {:?}, p2: {:?}", p1, p2); // 输出: p1: Point { x: 1, y: 2 }, p2: Point { x: 1, y: 2 }
    
    // 由于实现了Clone，可以显式克隆
    let p3 = p1.clone();
    println!("p3: {:?}", p3); // 输出: p3: Point { x: 1, y: 2 }
    
    // 由于实现了PartialEq，可以比较相等性
    println!("p1 == p2: {}", p1 == p2); // 输出: true
    
    // 由于实现了PartialOrd，可以比较大小
    let p4 = Point { x: 3, y: 4 };
    println!("p1 < p4: {}", p1 < p4); // 输出: true
}

注意：并非所有特性都可以派生，只有标注了#[derive]的特性才能使用这种方式。对于不能派生的特性，需要手动实现。

---

五、泛型与特性的实际应用

泛型和特性的结合使用可以实现强大的抽象和多态，同时保持 Rust 的类型安全和性能优势。

1. 多态实现

Rust 通过两种方式实现多态：

• 静态多态：通过泛型实现，在编译时确定具体类型
• 动态多态：通过特性对象（&dyn Trait）实现，在运行时确定具体类型

// 静态多态：编译时确定类型，生成专门的代码
fn print_area_static<T: Shape>(shape: T) {
    println!("Static polymorphism - Area: {:.2}", shape.area());
}

// 动态多态：运行时确定类型，通过特性对象实现
fn print_area_dynamic(shape: &dyn Shape) {
    println!("Dynamic polymorphism - Area: {:.2}", shape.area());
}

fn main() {
    let circle = Circle { radius: 2.0 };
    let rectangle = Rectangle { width: 3.0, height: 4.0 };
    
    // 静态多态
    print_area_static(circle); // 输出: Static polymorphism - Area: 12.57
    print_area_static(rectangle); // 输出: Static polymorphism - Area: 12.00
    
    // 重新创建对象（因为前面的已经被移动）
    let circle = Circle { radius: 2.0 };
    let rectangle = Rectangle { width: 3.0, height: 4.0 };
    
    // 动态多态：可以将不同类型放入同一集合
    let shapes: Vec<&dyn Shape> = vec![&circle, &rectangle];
    for shape in shapes {
        print_area_dynamic(shape);
    }
    // 输出:
    // Dynamic polymorphism - Area: 12.57
    // Dynamic polymorphism - Area: 12.00
}

2. 代码复用

通过泛型和特性可以创建通用组件，大幅减少代码冗余。

// 通用的计算面积总和的函数
fn total_area<T: Shape>(shapes: &[T]) -> f64 {
    shapes.iter().map(|s| s.area()).sum()
}

// 通用的筛选器：找出面积大于指定值的形状
fn filter_larger_than<T: Shape>(shapes: &[T], threshold: f64) -> Vec<&T> {
    shapes.iter().filter(|s| s.area() > threshold).collect()
}

fn main() {
    let circles = vec![
        Circle { radius: 1.0 },
        Circle { radius: 2.0 },
        Circle { radius: 3.0 },
    ];
    
    let rectangles = vec![
        Rectangle { width: 1.0, height: 1.0 },
        Rectangle { width: 2.0, height: 2.0 },
    ];
    
    println!("Total circle area: {:.2}", total_area(&circles)); // 输出: 43.98
    println!("Total rectangle area: {:.2}", total_area(&rectangles)); // 输出: 5.00
    
    let large_circles = filter_larger_than(&circles, 10.0);
    println!("Large circles count: {}", large_circles.len()); // 输出: 2
}

3. 自定义集合示例

结合泛型和特性实现一个简单的可排序集合：

// 定义一个可排序的集合
struct SortableCollection<T> {
    items: Vec<T>,
}

impl<T> SortableCollection<T> {
    fn new(items: Vec<T>) -> Self {
        SortableCollection { items }
    }
    
    fn len(&self) -> usize {
        self.items.len()
    }
}

// 为实现了Ord特性的类型添加排序功能
impl<T: Ord> SortableCollection<T> {
    fn sort(&mut self) {
        self.items.sort();
    }
}

// 为实现了Display特性的类型添加打印功能
impl<T: Display> SortableCollection<T> {
    fn print_items(&self) {
        for item in &self.items {
            print!("{}, ", item);
        }
        println!();
    }
}

fn main() {
    let mut numbers = SortableCollection::new(vec![3, 1, 4, 1, 5]);
    println!("Before sorting:");
    numbers.print_items(); // 输出: 3, 1, 4, 1, 5,
    numbers.sort();
    println!("After sorting:");
    numbers.print_items(); // 输出: 1, 1, 3, 4, 5,
}

4.通用栈数据结构（泛型的典型应用）

栈是一种常见的数据结构，通过泛型可以实现一个支持任意类型的通用栈，避免为每种类型重复实现相同逻辑。

// 泛型栈结构
struct Stack<T> {
    elements: Vec<T>,
}

// 为栈实现通用方法
impl<T> Stack<T> {
    // 创建空栈
    fn new() -> Self {
        Stack { elements: Vec::new() }
    }

    // 入栈
    fn push(&mut self, item: T) {
        self.elements.push(item);
    }

    // 出栈（返回Option，空栈时返回None）
    fn pop(&mut self) -> Option<T> {
        self.elements.pop()
    }

    // 查看栈顶元素
    fn peek(&self) -> Option<&T> {
        self.elements.last()
    }

    // 检查栈是否为空
    fn is_empty(&self) -> bool {
        self.elements.is_empty()
    }

    // 获取栈长度
    fn len(&self) -> usize {
        self.elements.len()
    }
}

// 为实现了Display特性的类型添加打印功能（特性约束应用）
use std::fmt::Display;
impl<T: Display> Stack<T> {
    fn print_elements(&self) {
        print!("Stack elements: ");
        for elem in &self.elements {
            print!("{} ", elem);
        }
        println!();
    }
}

fn main() {
    // 存储整数的栈
    let mut int_stack = Stack::new();
    int_stack.push(1);
    int_stack.push(2);
    int_stack.push(3);
    int_stack.print_elements(); // 输出: Stack elements: 1 2 3 
    println!("Popped: {:?}", int_stack.pop()); // 输出: Popped: Some(3)

    // 存储字符串的栈
    let mut str_stack = Stack::new();
    str_stack.push("hello");
    str_stack.push("world");
    str_stack.print_elements(); // 输出: Stack elements: hello world 
    println!("Top element: {:?}", str_stack.peek()); // 输出: Top element: Some("world")
}

5. 通用缓存系统（泛型 + 特性约束）

缓存系统需要存储键值对，通过泛型支持任意键值类型，同时通过特性约束确保键可哈希（用于快速查找）、值可克隆（用于缓存副本）。

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

// 泛型缓存结构：K为键类型，V为值类型
struct Cache<K, V> {
    data: HashMap<K, V>,
    max_size: usize, // 最大缓存容量
}

// 缓存的特性约束：K必须可哈希且可比较，V可以是任意类型
impl<K, V> Cache<K, V>
where
    K: Hash + Eq + Clone, // 新增Clone约束，因为需要克隆键
    V: Clone,
{
    // 创建新缓存
    fn new(max_size: usize) -> Self {
        Cache {
            data: HashMap::new(),
            max_size,
        }
    }

    // 添加缓存项（超出容量时简单清理最早项）
    fn insert(&mut self, key: K, value: V) {
        if self.data.len() >= self.max_size && !self.data.is_empty() {
            // 修复：正确获取并克隆第一个键
            if let Some((k, _)) = self.data.iter().next() {
                let key_to_remove = k.clone();
                self.data.remove(&key_to_remove);
            }
        }
        self.data.insert(key, value);
    }

    // 获取缓存项（返回克隆值，避免所有权转移）
    fn get(&self, key: &K) -> Option<V> {
        self.data.get(key).cloned()
    }

    // 检查缓存是否包含键
    fn contains_key(&self, key: &K) -> bool {
        self.data.contains_key(key)
    }
}

fn main() {
    // 字符串键 -> 整数值的缓存（最大容量2）
    let mut int_cache = Cache::new(2);
    int_cache.insert("a".to_string(), 100);
    int_cache.insert("b".to_string(), 200);
    println!("Get 'a': {:?}", int_cache.get(&"a".to_string())); // 输出: Some(100)

    // 插入第三个元素，触发清理
    int_cache.insert("c".to_string(), 300);
    println!("Contains 'a' after overflow: {}", int_cache.contains_key(&"a".to_string())); // 输出: false

    // 自定义类型作为键（需实现Hash、Eq）
    #[derive(Hash, Eq, PartialEq, Debug, Clone)] // 确保实现了Clone
    struct UserId(u64);
    
    let mut user_cache = Cache::new(1);
    user_cache.insert(UserId(1001), "Alice".to_string());
    println!("Get user 1001: {:?}", user_cache.get(&UserId(1001))); // 输出: Some("Alice")
}

6. 日志系统抽象（特性与多态）

日志系统需要支持多种输出方式（控制台、文件、网络），通过特性定义统一接口，不同输出方式实现该特性，实现 "同接口、多实现" 的多态效果。

use std::fs::OpenOptions;
use std::io::{self, Write};
use std::path::Path;

// 定义日志特性（抽象接口）
trait Logger {
    // 日志级别
    fn log_info(&mut self, message: &str);
    fn log_error(&mut self, message: &str);
    
    // 默认方法：通用日志格式化
    fn format_message(&self, level: &str, message: &str) -> String {
        format!("[{}] {}", level, message)
    }
}

// 控制台日志实现
struct ConsoleLogger;
impl Logger for ConsoleLogger {
    fn log_info(&mut self, message: &str) {
        let formatted = self.format_message("INFO", message);
        println!("{}", formatted);
    }
    
    fn log_error(&mut self, message: &str) {
        let formatted = self.format_message("ERROR", message);
        eprintln!("{}", formatted); // 错误输出到stderr
    }
}

// 文件日志实现
struct FileLogger {
    file: std::fs::File,
}
impl FileLogger {
    fn new(path: &str) -> io::Result<Self> {
        let file = OpenOptions::new()
            .create(true)
            .append(true)
            .open(Path::new(path))?;
        Ok(FileLogger { file })
    }
}
impl Logger for FileLogger {
    fn log_info(&mut self, message: &str) {
        let formatted = self.format_message("INFO", message);
        writeln!(self.file, "{}", formatted).unwrap();
    }
    
    fn log_error(&mut self, message: &str) {
        let formatted = self.format_message("ERROR", message);
        writeln!(self.file, "{}", formatted).unwrap();
    }
}

// 通用日志处理器（接受任意Logger实现）
fn process_with_logger(logger: &mut dyn Logger) {
    logger.log_info("Starting process...");
    logger.log_error("Something went wrong!");
    logger.log_info("Process finished");
}

fn main() {
    // 控制台日志
    let mut console_logger = ConsoleLogger;
    process_with_logger(&mut console_logger);
    
    // 文件日志（实际运行会创建log.txt）
    let mut file_logger = FileLogger::new("log.txt").unwrap();
    process_with_logger(&mut file_logger);
}

核心价值：Logger特性定义了统一的日志接口，ConsoleLogger和FileLogger分别实现了不同输出方式；process_with_logger函数通过dyn Logger特性对象接受任意日志实现，实现了 "接口与实现分离"，后续可轻松添加新的日志方式（如网络日志）而无需修改现有代码。

7. 数据验证框架（特性约束与代码复用）

在表单验证、数据校验等场景中，通过特性定义验证逻辑，为不同类型实现验证规则，再用泛型函数统一处理验证流程。

// 定义验证特性
trait Validatable {
    // 验证数据，返回错误信息（None表示验证通过）
    fn validate(&self) -> Option<String>;
}

// 为字符串实现验证（例如：非空且长度适中）
impl Validatable for String {
    fn validate(&self) -> Option<String> {
        if self.is_empty() {
            return Some("String cannot be empty".to_string());
        }
        if self.len() > 100 {
            return Some("String is too long (max 100 characters)".to_string());
        }
        None
    }
}

// 为整数实现验证（例如：年龄必须在0-120之间）
impl Validatable for i32 {
    fn validate(&self) -> Option<String> {
        if *self < 0 {
            return Some("Number cannot be negative".to_string());
        }
        if *self > 120 {
            return Some("Number exceeds maximum (120)".to_string());
        }
        None
    }
}

// 自定义用户类型
struct User {
    name: String,
    age: i32,
    email: String,
}

// 为用户实现验证（组合多个字段的验证）
impl Validatable for User {
    fn validate(&self) -> Option<String> {
        // 验证姓名
        if let Some(err) = self.name.validate() {
            return Some(format!("Name error: {}", err));
        }
        // 验证年龄
        if let Some(err) = self.age.validate() {
            return Some(format!("Age error: {}", err));
        }
        // 验证邮箱（简单检查@符号）
        if !self.email.contains('@') {
            return Some("Email is invalid (missing '@')".to_string());
        }
        None
    }
}

// 泛型验证器：批量验证一组数据
fn batch_validate<T: Validatable>(items: &[T]) -> Vec<Option<String>> {
    items.iter().map(|item| item.validate()).collect()
}

fn main() {
    // 验证单个值
    let name = "Alice".to_string();
    println!("Name validation: {:?}", name.validate()); // 输出: None（通过）
    
    let age = 150;
    println!("Age validation: {:?}", age.validate()); // 输出: Some("Number exceeds maximum (120)")

    // 验证用户
    let user = User {
        name: "".to_string(),
        age: 25,
        email: "invalid-email".to_string(),
    };
    println!("User validation: {:?}", user.validate()); // 输出: Some("Name error: String cannot be empty")

    // 批量验证
    let numbers = [5, -3, 100, 200];
    let results = batch_validate(&numbers);
    println!("Batch validation: {:?}", results);
    // 输出: [None, Some("Number cannot be negative"), None, Some("Number exceeds maximum (120)")]
}

核心价值：Validatable特性统一了验证接口，不同类型（String、i32、User）通过实现该特性定义自身的验证规则；batch_validate泛型函数利用特性约束T: Validatable，可以批量验证任意可验证类型的集合，实现了验证逻辑的复用。

---

总之，泛型和特性在实际开发中的核心价值：

• 泛型：通过参数化类型实现代码复用，让组件（如栈、缓存）适配任意数据类型。
• 特性：定义抽象接口，实现多态（如日志系统的多种输出方式），使代码更灵活。
• 特性约束：在保证灵活性的同时确保类型安全，例如缓存要求键可哈希、验证器要求数据可验证。