• 测试实例：链表
    • 参见：

    测试实例：链表

    enum 的一个常见用法就是创建链表（linked-list）：

    1. use List::*;
    3. enum List {
    4.     // Cons： 元组结构体，包含一个元素和一个指向下一节点的指针
    5.     Cons(u32, Box<List>),
    6.     // Nil： 末结点，表明链表结束
    7.     Nil,
    8. }
    10. // 方法可以在 enum 定义
    11. impl List {
    12.     // 创建一个空列表
    13.     fn new() -> List {
    14.         // `Nil` 为 `List` 类型
    15.         Nil
    16.     }
    18.     // 处理一个列表，得到一个头部带上一个新元素的同样类型的列表并返回此值
    19.     fn prepend(self, elem: u32) -> List {
    20.         // `Cons` 同样为 List 类型
    21.         Cons(elem, Box::new(self))
    22.     }
    24.     // 返回列表的长度
    25.     fn len(&self) -> u32 {
    26.         // `self` 必须匹配，因为这个方法的行为取决于 `self` 的变化类型
    27.         // `self` 为 `&List` 类型，`*self` 为 `List` 类型，一个具体的 `T` 类型的匹配
    28.         // 要参考引用 `&T` 的匹配
    29.         match *self {
    30.             // 不能得到 tail 的所有权，因为 `self` 是借用的；
    31.             // 而是得到一个 tail 引用
    32.             Cons(_, ref tail) => 1 + tail.len(),
    33.             // 基本情形：空列表的长度为 0
    34.             Nil => 0
    35.         }
    36.     }
    38.     // 将列表以字符串（堆分配的）的形式返回
    39.     fn stringify(&self) -> String {
    40.         match *self {
    41.             Cons(head, ref tail) => {
    42.                 // `format!` 和 `print!` 类似，但返回的是一个堆分配的字符串，而不是
    43.                 // 打印结果到控制台上
    44.                 format!("{}, {}", head, tail.stringify())
    45.             },
    46.             Nil => {
    47.                 format!("Nil")
    48.             },
    49.         }
    50.     }
    51. }
    53. fn main() {
    54.     // 创建一个空链表
    55.     let mut list = List::new();
    57.     // 追加一些元素
    58.     list = list.prepend(1);
    59.     list = list.prepend(2);
    60.     list = list.prepend(3);
    62.     // 显示链表的最后状态
    63.     println!("linked list has length: {}", list.len());
    64.     println!("{}", list.stringify());
    65. }

    参见：

    Box 和 方法