Rust 標記特徵與結構標記應用

– 10 分鐘閱讀

Rust 的型別系統提供強大的編譯時期檢查能力，讓開發者得以撰寫更安全的程式碼。標記特徵和結構標記是 Rust 中兩種特殊的技巧，可用於編譯時期的型別檢查和計算，提升程式碼的安全性和可維護性。標記特徵本身不帶有方法，主要用於標示特定型別，例如 Sync 和 Send 特徵，它們由編譯器實作，確保型別在多執行緒環境下的安全性。結構標記則利用空結構體作為泛型型別引數，在編譯時期進行狀態管理，類別似於 C++ 的範本元程式設計。本文將以學生管理系統為例，示範如何結合泛型、特徵和結構體標記，實作型別安全的狀態機制和參考物件。透過定義 Student、StudentRef 和 StudentList 等結構體，並結合特徵約束和生命週期管理，我們可以有效地封裝資料、控制存取許可權，並提供更清晰的程式碼結構。此外，本文也探討瞭如何利用泛型和特徵來實作狀態機制，以及如何使用參考物件來間接存取內部資料，避免直接暴露內部細節。

7.5 標記特徵（Marker Traits）

當熟悉特徵（traits）後，你可能會在其他 Rust 專案中注意到標記特徵的使用。標記特徵是抽象的特徵，它們標記或指示 Rust 中某個型別的特性或屬性，但不一定提供任何行為。（標記特徵通常以沒有方法為特徵。） 標記特徵沒有特定的使用場景；它們在許多情況下都很有用。

標記特徵與普通特徵的區別

標記特徵與普通特徵的不同之處在於，標記特徵不一定提供行為。例如，Sync 和 Send 特徵是標記特徵，但 Sync 和 Send 本身並不提供任何方法或功能。Sync 和 Send 是特殊情況，因為你甚至無法在不使用 unsafe 的情況下實作它們；只有編譯器才能安全地實作它們。

程式碼範例：定義一個標記特徵

#[derive(
    Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd,
)]
struct KitchenSink;

trait FullFeatured {}

內容解密：

這段程式碼定義了一個名為 KitchenSink 的空結構，並為其派生了多個特徵。同時，定義了一個名為 FullFeatured 的空標記特徵。

標記特徵的應用

一種形式的標記特徵提供了結合其他特徵的全覆寫實作。如果我們希望簡便地表示某個特定型別實作了一組給定的特徵，我們可以相應地標記它。考慮以下程式碼：

impl<T> FullFeatured for T where
    T: Clone
        + Copy
        + std::fmt::Debug
        + Default
        + Eq
        + std::hash::Hash
        + Ord
        + PartialEq
        + PartialOrd
{
}

內容解密：

這段程式碼為任何滿足特定約束的型別 T 實作了 FullFeatured 特徵。這些約束包括實作 Clone、Copy、Debug、Default、Eq、Hash、Ord、PartialEq 和 PartialOrd 等特徵。

使用標記特徵

現在我們可以使用我們的標記特徵來確保某個型別實作了所有這些特性，而無需每次都列出所有這些特性：

#[derive(Debug)]
struct Container<T: FullFeatured> {
    t: T,
}

let container = Container { t: KitchenSink {} };
println!("{:?}", container);

內容解密：

這段程式碼建立了一個名為 Container 的結構，它包含一個元素 t，並要求 T 實作 FullFeatured 特徵。由於我們已經為滿足特定約束的任何型別實作了 FullFeatured，因此 KitchenSink 自動滿足這個約束。

執行上述程式碼將輸出：

  Container { t: KitchenSink }

標記特徵的特點

標記特徵不一定要是空的，儘管它們通常是空的。你當然可以將具有方法的特徵視為標記特徵，但將它們混淆可能會讓其他人感到困惑。一般來說，標記特徵應該是空的（不包含任何方法或型別）。

7.6 結構標記（Struct Tagging）

有時，我們使用結構來標記或標籤泛型型別（具有泛型引數的型別）。這種方法稱為結構標記。使用結構標記，我們可以使用空結構（也稱為單元結構）透過將標籤作為未使用的型別引數包含在內來標記泛型型別；標籤本身不包含任何狀態，並且可能永遠不會被例項化。

結構標記的工作原理

與標記特徵類別似，用於標記的結構通常是空的；它們用於在型別系統本身內定義狀態。技巧在於，儘管我們使用的是旨在儲存狀態的抽象（在本例中為結構），但我們並沒有在結構內儲存任何執行時狀態；相反，我們使結構能夠用作泛型型別引數。

結構標記示意圖

  graph LR;
    A[泛型型別] -->|包含|> B[未使用的型別引數];
    B --> C[空結構];
    C -->|用於|> D[編譯時計算];

圖表翻譯： 此圖表展示了結構標記的概念，其中泛型型別包含一個未使用的型別引數，該引數是一個空結構，用於進行編譯時計算。

結構標記的應用場景

我們可以在希望在不使用巨集的情況下執行編譯時計算時使用結構標記。結構標記引入了一點複雜性，但具有編譯時檢查和型別安全的優勢。在 C++ 術語中，這種方法是一種範本元程式設計形式，例如 Boost 的 MPL 所使用的那種形式。

超級特徵（Supertraits）

在這一點上，值得討論超級特徵，它們指定由其他特徵組成的特徵，就像我們在 FullFeatured 特徵的例子中所做的那樣。

程式碼範例：定義一個超級特徵

trait CloneAndDebug: Clone + Debug {}

內容解密：

這段程式碼定義了一個名為 CloneAndDebug 的超級特徵，它要求實作它的型別同時實作 Clone 和 Debug 特徵。

超級特徵與全覆寫實作的比較

使用超級特徵和使用具有特徵約束的全覆寫實作（就像我們對 FullFeatured 所做的那樣）之間的區別在於，超級特徵給我們帶來了稍微少一些的靈活性（由於編譯器的嚴格性）和更多的便利性。使用超級特徵時，除非我們的型別同時實作了 Clone 和 Debug，否則我們無法派生 CloneAndDebug 特徵。使用全覆寫實作則允許我們為特定型別做出特殊的例外。

程式碼範例：為超級特徵提供預設實作

trait CloneAndDebug: Clone + Debug {
    fn clone_and_dbg(&self) -> Self {
        let r = self.clone();
        dbg!(&r);
        r
    }
}

內容解密：

這段程式碼為 CloneAndDebug 特徵提供了一個預設方法 clone_and_dbg，該方法克隆自身，除錯列印克隆結果，並傳回克隆結果。

總之，超級特徵和結構標記都是 Rust 中強大的工具，它們允許我們在編譯時進行更精確的型別檢查和計算，從而提高程式碼的安全性和可維護性。

使用特徵、泛型和結構體進行專門任務的處理

在軟體開發中，使用泛型和特徵（trait）可以大幅提高程式碼的彈性和安全性。透過將狀態和行為抽象化，我們可以建立更強壯的系統。本章節將探討如何利用結構體標記（struct tagging）來實作狀態機制，並介紹參考物件（reference objects）的使用方法。

結構體標記與狀態機制

結構體標記是一種利用泛型和空結構體（unit structs）來表示不同狀態的方法。這種方法的最大優勢在於它是型別安全的，並且可以在編譯時期被檢查，從而減少執行時期的錯誤。

實作範例：燈泡狀態管理

考慮一個簡單的燈泡模型，它具有「開啟」和「關閉」兩種狀態。我們可以定義一個泛型結構體 LightBulb，並使用空結構體 On 和 Off 來表示不同的狀態。

trait BulbState {}
struct LightBulb<State: BulbState> {
    phantom: PhantomData<State>,
}
struct On {}
struct Off {}
impl BulbState for On {}
impl BulbState for Off {}

在這個範例中，我們定義了一個 BulbState 特徵，並讓 On 和 Off 結構體實作了這個特徵。LightBulb 結構體被定義為一個泛型結構體，它接受任何實作了 BulbState 特徵的型別作為其狀態引數。

狀態轉換方法

為了在不同狀態之間進行轉換，我們可以為 LightBulb 實作特定狀態下的方法。例如，當燈泡處於開啟狀態時，我們可以實作一個 turn_off 方法來將其狀態轉換為關閉。

impl LightBulb<On> {
    fn turn_off(self) -> LightBulb<Off> {
        LightBulb::<Off>::default()
    }
    
    fn state(&self) -> &str {
        "on"
    }
}

impl LightBulb<Off> {
    fn turn_on(self) -> LightBulb<On> {
        LightBulb::<On>::default()
    }
    
    fn state(&self) -> &str {
        "off"
    }
}

測試範例

let lightbulb = LightBulb::<Off>::default();
println!("燈泡狀態：{}", lightbulb.state());
let lightbulb = lightbulb.turn_on();
println!("燈泡狀態：{}", lightbulb.state());
let lightbulb = lightbulb.turn_off();
println!("燈泡狀態：{}", lightbulb.state());

輸出結果：

  燈泡狀態：off
燈泡狀態：on
燈泡狀態：off

#### 內容解密：

  1. 泛型結構體的定義：LightBulb 被定義為一個泛型結構體，接受一個型別引數 State，該引數必須實作 BulbState 特徵。
  2. 狀態表示：使用空結構體 On 和 Off 來表示燈泡的不同狀態，這些結構體實作了 BulbState 特徵。
  3. 狀態轉換：透過為 LightBulb 實作特定狀態下的方法（如 turn_on 和 turn_off），我們可以在不同狀態之間進行轉換。這些方法會消耗原有的 LightBulb 例項並傳回一個新的例項，以實作狀態的轉換。
  4. 型別安全：由於使用了泛型和特徵約束，編譯器可以在編譯時期檢查狀態轉換的正確性，從而避免執行時期的錯誤。

參考物件的使用

參考物件提供了一種方式來存取內部資料而不暴露其實作細節。透過使用參考物件，我們可以在不公開內部資料結構的情況下，提供對資料的參照。

實作範例：學生列表與參考物件

考慮一個學生列表的例子，我們希望提供對個別學生的參照，但不直接暴露內部資料。

#[derive(Debug)]
struct Student {
    name: String,
    id: u32,
}

#[derive(Debug)]
pub struct StudentList {
    students: Vec<Student>,
}

#[derive(Debug)]
pub struct StudentRef<'a> {
    student: &'a Student,
}

在這個範例中，Student 是私有的，而 StudentList 是公開的。我們定義了一個 StudentRef 結構體來持有對 Student 的參照。

#### 內容解密：

  1. 私有資料結構：Student 結構體是私有的，以避免直接暴露內部資料。
  2. 公開參考物件：StudentRef 是公開的，它持有對 Student 的參照，允許在不暴露內部資料的情況下存取學生資料。
  3. 生命週期引數：StudentRef 使用了生命週期引數 'a，確保參照的有效性與所參照的 Student 例項一致。

結語

本章節介紹瞭如何使用特徵、泛型和結構體來實作專門的任務，如狀態機制的管理和參考物件的使用。這些技術能夠提高程式碼的型別安全性、可讀性和可維護性。在實際開發中，合理運用這些技術可以幫助我們構建更強壯、更靈活的軟體系統。未來，我們將繼續探索更多高階的 Rust 程式設計技術，以進一步提升我們的開發能力。

參考物件的實作與應用

在前面的章節中，我們探討瞭如何使用泛型、特徵（traits）以及結構體（structs）來完成特定的任務。本文將深入研究參考物件（Reference objects）的概念，並透過一個具體的例子來展示其實作和應用。

學生管理系統範例

假設我們需要建立一個學生管理系統，用於儲存和管理學生的資訊。我們首先定義一個 Student 結構體來表示學生：

#[derive(Debug)]
struct Student {
    name: String,
    id: u32,
}

impl Student {
    fn new(name: String, id: u32) -> Self {
        Self { name, id }
    }

    fn name(&self) -> &str {
        self.name.as_ref()
    }

    fn id(&self) -> u32 {
        self.id
    }
}

建立參考物件

為了能夠在不暴露內部 Student 物件的情況下提供對學生資訊的存取，我們引入了一個名為 StudentRef 的參考物件：

#[derive(Debug)]
pub struct StudentRef<'a> {
    student: &'a Student,
}

impl<'a> StudentRef<'a> {
    fn new(student: &'a Student) -> Self {
        Self { student }
    }
}

這裡，StudentRef 持有對 Student 物件的參照，其生命週期與所參照的 Student 物件相同。

實作學生列表

接下來，我們定義了一個 StudentList 結構體，用於管理多個學生：

#[derive(Debug)]
pub struct StudentList {
    students: Vec<Student>,
}

impl StudentList {
    pub fn new(students: &[(&str, u32)]) -> Self {
        Self {
            students: students
                .iter()
                .map(|(name, id)| Student::new((*name).into(), *id))
                .collect(),
        }
    }
}

查詢功能實作

為了方便地查詢學生，我們在 StudentList 上實作了根據 ID 和姓名查詢學生的方法：

impl<'a> StudentList {
    fn find<F: Fn(&&Student) -> bool>(&'a self, pred: F) -> Option<StudentRef<'a>> {
        self.students.iter().find(pred).map(Student::to_ref)
    }

    pub fn find_student_by_id(&'a self, id: u32) -> Option<StudentRef<'a>> {
        self.find(|s| s.id() == id)
    }

    pub fn find_student_by_name(&'a self, name: &str) -> Option<StudentRef<'a>> {
        self.find(|s| s.name() == name)
    }
}

測試查詢功能

透過以下程式碼測試我們的查詢功能：

let student_list = StudentList::new(&[("Lyle", 621), ("Anna", 286)]);
dbg!(&student_list);
dbg!(student_list.find_student_by_id(621));
dbg!(student_list.find_student_by_name("Anna"));

執行結果如下：

  [src/main.rs:84] &student_list = StudentList {
    students: [
        Student {
            name: "Lyle",
            id: 621,
        },
        Student {
            name: "Anna",
            id: 286,
        },
    ],
}
[src/main.rs:85] student_list.find_student_by_id(621) = Some(
    StudentRef {
        student: Student {
            name: "Lyle",
            id: 621,
        },
    },
)
[src/main.rs:86] student_list.find_student_by_name("Anna") = Some(
    StudentRef {
        student: Student {
            name: "Anna",
            id: 286,
        },
    },
)

比較參考物件

為了比較兩個 StudentRef 物件是否指向同一個學生，我們為 StudentRef 實作了 PartialEq 特徵：

impl<'a> PartialEq for StudentRef<'a> {
    fn eq(&self, other: &Self) -> bool {
        self.student.id() == other.student.id()
    }
}

測試比較功能：

let student_ref_621 = student_list.find_student_by_id(621).unwrap();
let student_ref_286 = student_list.find_student_by_id(286).unwrap();
dbg!(student_ref_286 == student_ref_621);
dbg!(student_ref_286 != student_ref_621);

輸出結果為：

  [src/main.rs:99] student_ref_286 == student_ref_621 = false
[src/main.rs:100] student_ref_286 != student_ref_621 = true
詳細實作說明：
  1. Student 結構體：定義了學生的基本資訊，包括姓名和學號，並提供了建構函式和取得學生資訊的方法。
  2. StudentRef 結構體：作為 Student 的參考物件，提供了一個安全的介面來存取 Student 資訊而不直接暴露 Student 物件。
  3. StudentList 結構體：用於管理多個 Student 物件，提供了初始化和查詢學生資訊的功能。
  4. 查詢功能的實作：透過實作 find 方法及其衍生的 find_student_by_id 和 find_student_by_name 方法，能夠根據不同條件查詢學生。
  5. PartialEq 特徵的實作：允許比較兩個 StudentRef 物件是否指向同一個學生。

這些實作細節展示了 Rust 在資料封裝和安全存取控制方面的強大能力。透過合理地使用結構體、特徵和生命週期，開發者能夠寫出既高效又安全的程式碼。

圖表說明

以下是用 Mermaid 圖表來說明 Student、StudentRef 和 StudentList 之間的關係：

  classDiagram
    class Student {
        -name: String
        -id: u32
        +new(name: String, id: u32)
        +name(): &str
        +id(): u32
        +to_ref(): StudentRef
    }

    class StudentRef {
        -student: &Student
        +new(student: &Student)
    }

    class StudentList {
        -students: Vec~Student~
        +new(students: &[(&str, u32)])
        +find_student_by_id(id: u32): Option~StudentRef~
        +find_student_by_name(name: &str): Option~StudentRef~
    }

    StudentList "1" --> "*" Student : contains
    StudentRef "1" --> "1" Student : references

圖表翻譯： 此圖表展示了 Student、StudentRef 和 StudentList 三個類別之間的關係。StudentList 可以包含多個 Student 物件，而每個 StudentRef 物件則參考一個 Student 物件。這種設計使得我們可以在不直接存取 Student 物件的情況下，透過 StudentRef 間接存取學生資訊。

程式碼擴充套件與改進方向

  1. 增加可變參考物件：目前的 StudentRef 是不可變的，可以考慮實作一個可變版本，例如命名為 StudentMutRef，以支援對學生資訊的修改。
  2. 最佳化查詢效能：對於大規模的學生資料，可以考慮使用更高效的資料結構（如雜湊表或二分搜尋樹）來最佳化查詢效能。
  3. 擴充功能：可以進一步擴充 StudentList 的功能，例如支援排序、刪除學生等操作，以滿足更多實際需求。

透過這些改進，可以使我們的學生管理系統更加完善和強大。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。