35 泛型之泛型结构体与枚举

在我们之前的教程中，我们介绍了如何定义泛型函数。通过泛型函数，我们可以编写能够处理不同类型数据的函数，从而提高代码的复用性和灵活性。在本篇教程中，我们将深入探讨泛型的另一个重要方面——泛型结构体和枚举。通过这些组合，我们能够在Rust中创建更加复杂和通用的数据结构。

泛型结构体

泛型结构体是一个定义时可以接受类型参数的结构体。这使得同一个结构体可以操作不同类型的数据。

示例：定义一个泛型结构体

下面是一个简化的示例，我们定义一个名为 Pair 的结构体，它能够持有两个同类型的值。

struct Pair<T> {
    first: T,
    second: T,
}

impl<T> Pair<T> {
    fn new(first: T, second: T) -> Self {
        Pair { first, second }
    }

    fn get_first(&self) -> &T {
        &self.first
    }

    fn get_second(&self) -> &T {
        &self.second
    }
}

fn main() {
    let int_pair = Pair::new(1, 2);
    println!("first: {}, second: {}", int_pair.get_first(), int_pair.get_second());
    
    let string_pair = Pair::new(String::from("hello"), String::from("world"));
    println!("first: {}, second: {}", string_pair.get_first(), string_pair.get_second());
}

在这个示例中，我们定义了一个 Pair<T> 结构体，它包含两个同类型的字段 first 和 second。使用泛型 T 使得 Pair 的实例可以存储任意类型的数据。在 main 函数中，我们分别创建了一个整数对和一个字符串对，显示了泛型结构体的灵活性。

使用多个泛型

我们也可以定义接受多个类型参数的结构体：

struct Triple<X, Y, Z> {
    first: X,
    second: Y,
    third: Z,
}

impl<X, Y, Z> Triple<X, Y, Z> {
    fn new(first: X, second: Y, third: Z) -> Self {
        Triple { first, second, third }
    }
}

fn main() {
    let mixed = Triple::new(42, 'A', "Hello");
    // 这里可以继续实现相应的 Getter 方法
}

在这个例子中，Triple<X, Y, Z> 结构体同时接受三个不同类型的参数。这样我们可以在一个结构体中同时存储多种类型的信息。

泛型枚举

泛型同样可以应用于枚举类型。使用泛型枚举，我们可以定义能够存储多种类型的枚举值。

示例：定义一个泛型枚举

下面是一个简单的例子，定义一个名为 Option 的枚举，类似于Rust标准库中已经存在的 Option。

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

fn main() {
    let some_value: Option<i32> = Option::Some(10);
    let no_value: Option<i32> = Option::None;

    match some_value {
        Option::Some(v) => println!("Got a value: {}", v),
        Option::None => println!("No value"),
    }

    match no_value {
        Option::Some(v) => println!("Got a value: {}", v),
        Option::None => println!("No value"),
    }
}

在这个例子中，Option<T> 枚举可以存储一个值或表示一个空值。我们使用 match 语句来对枚举的不同变体进行模式匹配，从而决定相应的处理逻辑。

泛型枚举的实际应用

我们可以使用泛型枚举创建更复杂的结构。例如，定义一个表示树节点的枚举：

enum TreeNode<T> {
    Node(T, Box<TreeNode<T>>, Box<TreeNode<T>>),
    Leaf,
}

fn main() {
    let leaf = TreeNode::Leaf;
    let node = TreeNode::Node(5, Box::new(leaf), Box::new(TreeNode::Node(10, Box::new(TreeNode::Leaf), Box::new(TreeNode::Leaf))));
    // 可以进一步实现树的遍历或其他操作
}

在这个例子中，TreeNode<T> 枚举表示一颗树的节点。每个节点可以是一个 Node，它持有一个值和左右子节点的引用，或者是一个 Leaf，表示树的终止。

总结

在本篇教程中，我们学习了如何定义泛型结构体和枚举。泛型的应用提高了我们的代码灵活性和复用性，使我们能够创建可以处理不同类型的数据结构。在下一篇教程中，我们将深入探讨 Trait bounds，以讲解如何约束泛型参数的类型，从而使我们的代码更加安全和高效。

通过这些工具的组合，Rust 提供了一种类型安全的方式来编写强大的和灵活的代码。