Rust 泛型特徵與複數結構設計與實作

– 10 分鐘閱讀

Rust 的泛型和特徵系統允許開發者編寫更具彈性且可重複使用的程式碼。本文將以複數結構的設計與實作為例，展示如何利用泛型和特徵來定義複數型別，並實作其基本運算和格式化輸出。同時，我們也將探討 Rust 中的錯誤處理機制，以及遞迴和迭代器的應用，並提供相關程式碼範例與測試案例，以幫助讀者更好地理解這些概念。透過本文的學習，讀者可以更深入地瞭解 Rust 的泛型和特徵系統，並掌握如何應用這些特性來編寫更具彈性、可維護性和高效的程式碼。

型別別名的優點

Rust 的型別別名有以下優點：

  • 型別別名可以簡化型別名稱，減少程式碼的複雜性。
  • 型別別名可以提高程式碼的可讀性，讓程式碼更容易理解。

泛型的應用

在程式設計中，泛型是一種強大的工具，能夠讓我們定義出更具彈性的資料型別和結構。泛型的主要優點是可以減少重複的程式碼，並提高程式的可讀性和可維護性。

泛型函式

在Rust中，泛型函式的定義使用 <> 來指定泛型引數。例如：

fn greater<T: Ord>(one: T, two: T) -> T {
    match one.cmp(&two) {
        Ordering::Less => two,
        Ordering::Greater => one,
        Ordering::Equal => one,
    }
}

這個函式可以接受任何實作了 Ord 特性的資料型別，並傳回兩個引數中較大的那一個。

多重特性

如果我們需要指定多個特性給泛型引數，可以使用 + 來連線多個特性。例如：

fn greater_alt<T: Ord + Display>(one: T, two: T) {
    match one.cmp(&two) {
        Ordering::Less => println!("{} is greater", two),
        Ordering::Greater => println!("{} is greater", one),
        Ordering::Equal => println!("They are equal"),
    }
}

這個函式需要 T 實作了 Ord 和 Display 兩個特性。

where 關鍵字

如果我們需要指定多個特性給泛型引數，函式定義可能會變得很長。這時候可以使用 where 關鍵字來指定特性。例如：

fn greater_alt<T>(one: T, two: T)
where
    T: Ord + Display,
{
    match one.cmp(&two) {
        Ordering::Less => println!("{} is greater", two),
        Ordering::Greater => println!("{} is greater", one),
        Ordering::Equal => println!("They are equal"),
    }
}

這個函式的定義更為簡潔和易於閱讀。

泛型結構

泛型結構的定義也很類似。例如：

struct Foo<T: Bar> {
    a: T,
    b: T,
}

實作泛型結構的方法也需要指定泛型引數。例如：

impl<T: Bar> Foo<T> {
    // ...
}

這些是Rust中泛型的基本應用。泛型可以讓我們寫出更具彈性和可重用的程式碼。

什麼是泛型和特徵在 Rust 中的作用？

在 Rust 中，泛型和特徵是兩個非常重要的概念，讓我們可以建立更靈活和更強大的程式碼。

泛型

泛型是 Rust 中的一種機制，允許我們定義可以工作於多種資料型別的函式和資料結構。這意味著我們可以建立一個泛型函式或資料結構，它可以處理任何型別的資料，而不需要為每種資料型別都建立一個單獨的版本。

例如，以下是一個簡單的泛型函式：

fn identity<T>(x: T) -> T {
    x
}

這個函式可以工作於任何型別的資料，包括整數、浮點數數、字串等。

特徵

特徵（trait）是 Rust 中的一種機制，允許我們定義一組方法和行為，可以被多個資料型別實作。這意味著我們可以建立一個特徵，它定義了一組方法和行為，然後讓多個資料型別實作這個特徵。

例如，以下是一個簡單的特徵：

trait Printable {
    fn print(&self);
}

這個特徵定義了一個 print 方法，可以被多個資料型別實作。

實作特徵

要實作一個特徵，我們需要使用 impl 關鍵字，然後指定特徵的名稱和資料型別。例如：

struct Person {
    name: String,
}

impl Printable for Person {
    fn print(&self) {
        println!("Name: {}", self.name);
    }
}

這個程式碼實作了 Printable 特徵於 Person 結構體上。

泛型和特徵的結合

泛型和特徵可以結合使用，建立更強大的程式碼。例如：

trait Printable<T> {
    fn print(&self, x: T);
}

struct Person {
    name: String,
}

impl<T> Printable<T> for Person {
    fn print(&self, x: T) {
        println!("Name: {}, Value: {:?}", self.name, x);
    }
}

這個程式碼定義了一個 Printable 特徵，它有一個泛型引數 T。然後，實作了這個特徵於 Person 結構體上，使用泛型引數 T。

重點摘要

  • 泛型是 Rust 中的一種機制，允許我們定義可以工作於多種資料型別的函式和資料結構。
  • 特徵是 Rust 中的一種機制，允許我們定義一組方法和行為，可以被多個資料型別實作。
  • 泛型和特徵可以結合使用，建立更強大的程式碼。
  • impl 關鍵字用於實作特徵。
  • trait 關鍵字用於定義特徵。

練習題

  1. 實作一個 Printable 特徵於 Vec 結構體上。
  2. 實作一個 Printable 特徵於 HashMap 結構體上。
  3. 定義一個泛型函式，接受一個 Printable 特徵的實作者作為引數。
  4. 實作一個 Printable 特徵於 Person 結構體上，使用泛型引數 T。

複數運算函式庫

複數結構

首先，我們需要定義一個複數結構，包含實數和虛數兩個部分。這個結構需要實作加法和減法運算。

use std::fmt::{Display, Formatter};
use std::ops::{Add, Sub};

#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
pub struct Complex<T> {
    /// 實數部分
    pub r: T,
    /// 虛數部分
    pub i: T,
}

impl<T: Copy + Clone + Add<Output = T> + Sub<Output = T>> Complex<T> {
    /// 建立一個新的複數
    pub fn new(r: T, i: T) -> Self {
        Complex { r, i }
    }
}

加法和減法運算

接下來，我們需要實作加法和減法運算。這可以透過實作 Add 和 Sub 特徵來完成。

impl<T: Copy + Clone + Add<Output = T> + Sub<Output = T>> Add for Complex<T> {
    type Output = Complex<T>;

    fn add(self, other: Complex<T>) -> Complex<T> {
        Complex {
            r: self.r + other.r,
            i: self.i + other.i,
        }
    }
}

impl<T: Copy + Clone + Add<Output = T> + Sub<Output = T>> Sub for Complex<T> {
    type Output = Complex<T>;

    fn sub(self, other: Complex<T>) -> Complex<T> {
        Complex {
            r: self.r - other.r,
            i: self.i - other.i,
        }
    }
}

顯示複數

最後，我們需要實作 Display 特徵，以便可以顯示複數。

impl<T: Display> Display for Complex<T> {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "{} + {}i", self.r, self.i)
    }
}

測試

現在，我們可以測試我們的複數結構和運算。

fn main() {
    let c1 = Complex::new(1, 2);
    let c2 = Complex::new(3, 4);

    let sum = c1 + c2;
    let diff = c1 - c2;

    println!("c1: {}", c1);
    println!("c2: {}", c2);
    println!("sum: {}", sum);
    println!("diff: {}", diff);
}

這個程式會輸出：

c1: 1 + 2i
c2: 3 + 4i
sum: 4 + 6i
diff: -2 + -2i

複數運算與格式化

介紹

在本節中，我們將實作一個複數結構體，並提供加法、減法運算，以及自訂格式化輸出。同時，我們還會實作從元組到複數的轉換。

實作複數結構體

首先，我們定義一個 Complex 結構體，包含實部 r 和虛部 i：

pub struct Complex<T> {
    r: T,
    i: T,
}

加法與減法運算

接下來，我們實作 add 和 sub 方法，分別對複數進行加法和減法運算：

impl<T> Complex<T> {
    pub fn new(r: T, i: T) -> Self {
        Complex { r, i }
    }

    pub fn add(&mut self, other: &Self) {
        self.r = self.r + other.r;
        self.i = self.i + other.i;
    }

    pub fn sub(&mut self, other: &Self) {
        self.r = self.r - other.r;
        self.i = self.i - other.i;
    }
}

自訂格式化輸出

為了能夠以特定的格式輸出複數，我們實作了 Display 特徵：

use std::fmt;

impl<T: fmt::Display> fmt::Display for Complex<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{} + {}i", self.r, self.i)
    }
}

從元組到複數的轉換

我們實作了 From<(T, T)> 特徵，以便能夠從元組建立複數：

impl<T> From<(T, T)> for Complex<T> {
    fn from(t: (T, T)) -> Self {
        Complex {
            r: t.0,
            i: t.1,
        }
    }
}

測試

最後，我們寫了一個簡單的測試來驗證加法和減法運算的正確性：

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_complex() {
        let mut complex = Complex::new(8, 7);
        complex.add(&Complex::new(9, 8));
        complex.sub(&Complex::from((7, 6)));
        assert_eq!(complex, Complex::new(10, 9));
    }
}

執行測試

當我們執行 cargo test 時，應該會看到如下結果：

Finished test [unoptimized + debuginfo] target(s) in 0.82s
Running unittests src/lib.rs (target/debug/deps/ch2_exercises-eca3ee4d1f38c108)

圖表翻譯：

  graph LR
    A[複數結構體] --> B[加法運算]
    A --> C[減法運算]
    A --> D[自訂格式化輸出]
    A --> E[從元組到複數的轉換]
    B --> F[測試]
    C --> F
    D --> F
    E --> F

內容解密：

以上程式碼實作了複數的基本運算和格式化輸出，同時也提供了從元組到複數的轉換功能。這些功能可以用於各種數學和科學應用中。

實作排序功能的列舉型別

在這個例子中，我們需要建立一個列舉型別 Status，它可以實作 PartialOrd 特徵，以便對一個 Status 陣列進行排序。為了簡化這個過程，我們定義了一個列舉型別 Status，它有三個變體：Done、InProgress 和 Planned。我們使用 #[repr(i8)] 來指定這個列舉型別可以被表示為一個 8 位元的整數，這樣我們就可以為每個變體分配一個特定的整數值。

#[derive(Debug, Clone, PartialEq, PartialOrd)]
#[repr(i8)]
pub enum Status {
    Done = 1,
    InProgress = 0,
    Planned = -1,
}

實作排序函式

接下來，我們需要實作一個排序函式 sort_status，它可以對一個 Status 陣列進行排序。這個函式使用 sort_by 方法和 partial_cmp 方法來比較陣列中的元素，並對它們進行排序。

pub fn sort_status(statuses: &mut Vec<Status>) {
    // 使用 sort_by 方法和 partial_cmp 方法來排序
    statuses.sort_by(|low, high| high.partial_cmp(&low).unwrap());
}

測試排序函式

最後，我們需要測試這個排序函式是否正確地排序了 Status 陣列。為了做到這一點，我們建立了一個測試函式 test_part_ord，它會對一個 Status 陣列進行排序，並使用 assert_eq! 宏來驗證排序結果是否正確。

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_part_ord() {
        let mut statuses = vec![Done, InProgress, Planned, Planned, Done, InProgress];
        sort_status(&mut statuses);
        assert_eq!(statuses, vec![Done, Done, InProgress, InProgress, Planned, Planned]);
    }
}

當我們執行這個測試函式時，我們可以看到排序結果是否正確。這個測試函式會對 Status 陣列進行排序，並驗證排序結果是否與預期結果一致。如果排序結果正確，則測試函式會透過；否則，測試函式會失敗，並顯示錯誤資訊。

自訂連結串列結構：Archiver

介紹

為了滿足特定的需求，我們設計了一個名為 Archiver 的結構，類似於連結串列，但具有不同的特點。這個結構包含兩個主要成員：value 和 archive。value 代表當前的值，而 archive 是一個儲存過去值的向量。

Archiver 結構定義

use std::iter::IntoIterator;

#[derive(Debug, Clone, PartialOrd, PartialEq)]
pub struct Archiver {
    pub value: Option<i32>,
    pub archive: Vec<i32>,
}

方法實作

new 方法

建立一個新的、空的 Archiver 例項。

impl Archiver {
    pub fn new() -> Self {
        Self {
            value: None,
            archive: Vec::new(),
        }
    }
}

push 方法

將一個新的值推入 Archiver 中。如果 value 是 None，直接將新值賦給 value。如果 value 已經存在，則將現有的值推入 archive 中，並更新 value 為新值。

pub fn push(&mut self, value: i32) {
    if self.value.is_none() {
        self.value = Some(value);
    } else {
        self.archive.push(self.value.unwrap());
        self.value = Some(value);
    }
}

pop 方法

移除並傳回當前的 value，並從 archive 中取出最後一個元素作為新的 value。

pub fn pop(&mut self) -> Option<i32> {
    if let Some(current_value) = self.value.take() {
        self.value = self.archive.pop();
        Some(current_value)
    } else {
        None
    }
}

實作與測試

fn main() {
    let mut archiver = Archiver::new();
    archiver.push(10);
    archiver.push(20);
    archiver.push(30);
    
    println!("Archiver: {:?}", archiver);
    
    let popped_value = archiver.pop();
    println!("Popped value: {:?}", popped_value);
    println!("Archiver after pop: {:?}", archiver);
}

這個實作提供了一個基本的 Archiver 結構，具有 push 和 pop 方法，滿足了特定的需求。

實作 Archiver 的 IntoIterator

為了實作 Archiver 的 IntoIterator，我們需要定義 Item 和 IntoIter 型別。Item 代表了迭代器中每個專案的型別，在本例中為 i32。IntoIter 代表了我們要轉換成的迭代器型別，我們選擇使用 std::vec::IntoIter。

impl IntoIterator for Archiver {
    type Item = i32;
    type IntoIter = std::vec::IntoIter<Self::Item>;

    fn into_iter(self) -> Self::IntoIter {
        self.archive.into_iter()
    }
}

測試 Archiver 的迭代器

現在，我們可以建立一個測試來驗證 Archiver 的迭代器是否按預期工作。

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_archiver_iterator() {
        let mut archiver = Archiver::new();
        archiver.push(1);
        archiver.push(2);
        archiver.push(3);

        let mut iter = archiver.into_iter();
        assert_eq!(iter.next(), Some(1));
        assert_eq!(iter.next(), Some(2));
        assert_eq!(iter.next(), Some(3));
        assert_eq!(iter.next(), None);
    }
}

在這個測試中，我們建立了一個 Archiver 例項，然後推入三個值。接著，我們將 Archiver 轉換成迭代器，並驗證迭代器是否正確地傳回了這三個值。

實作 Archiver 的 pop 方法

Archiver 的 pop 方法從存檔中彈出一個值，並將其設定為當前的值。

pub fn pop(&mut self) -> Option<i32> {
    let value = self.value.take();
    let new_value = self.archive.pop();
    self.value = new_value;
    value
}

測試 Archiver 的 pop 方法

現在，我們可以建立一個測試來驗證 Archiver 的 pop 方法是否按預期工作。

#[test]
fn test_archiver_pop() {
    let mut archiver = Archiver::new();
    archiver.push(1);
    archiver.push(2);
    archiver.push(3);

    assert_eq!(archiver.pop(), Some(3));
    assert_eq!(archiver.pop(), Some(2));
    assert_eq!(archiver.pop(), Some(1));
    assert_eq!(archiver.pop(), None);
}

在這個測試中，我們建立了一個 Archiver 例項，然後推入三個值。接著，我們彈出這三個值，並驗證 pop 方法是否正確地傳回了這三個值。最後，我們驗證彈出一個不存在的值時，pop 方法是否傳回 None。

Rust 中的遞迴與迭代器

在 Rust 中，遞迴和迭代器是兩種不同的程式設計方法。遞迴是一種函式呼叫自己的方法，而迭代器是一種可以遍歷集合的物件。

遞迴

遞迴是一種函式呼叫自己的方法，可以用來解決一些特定的問題。例如，計算一個數字的階乘可以使用遞迴來實作：

fn factorial(n: u32) -> u32 {
    match n {
        0 => 1,
        _ => n * factorial(n - 1),
    }
}

但是，遞迴也有一些缺點，例如可能會導致堆積疊溢位，如果遞迴太深。

迭代器

迭代器是一種可以遍歷集合的物件，可以用來解決一些特定的問題。例如，遍歷一個向量的元素可以使用迭代器來實作：

let vec = vec![1, 2, 3, 4, 5];
for elem in vec {
    println!("{}", elem);
}

迭代器也可以用來實作一些複雜的演算法，例如對映和篩選。

Archiver 的實作

在上面的程式碼中，Archiver 是一個結構體，它有兩個欄位：value 和 archive。value 是一個可選的整數，archive 是一個向量，包含了一些整數。

struct Archiver {
    value: Option<u32>,
    archive: Vec<u32>,
}

Archiver 的 push 方法可以將一個整數新增到 archive 中，並更新 value 欄位：

impl Archiver {
    fn push(&mut self, value: u32) {
        self.archive.push(self.value.unwrap_or(0));
        self.value = Some(value);
    }
}

Archiver 的 archive 方法可以將 archive 中的每個元素乘以 2：

impl Archiver {
    fn archive(&mut self) {
        self.archive = self.archive.clone().into_iter().map(|x| x * 2).collect();
    }
}

測試

上面的程式碼中，有一個測試函式 test_iter，它可以測試 Archiver 的 push 和 archive 方法：

#[test]
fn test_iter() {
    let mut archiver = Archiver::new();
    archiver.push(90);
    archiver.push(67);
    archiver.push(88);
    archiver.archive();
    assert_eq!(archiver, Archiver {
        value: Some(88),
        archive: vec![180, 134],
    });
}

這個測試函式可以確保 Archiver 的 push 和 archive 方法正確地工作。

錯誤處理

錯誤處理是任何程式設計語言中的一個非常重要的主題，因為它允許開發人員處理程式中的邊緣案例或預防使用者錯誤。無論如何，知道如何處理錯誤是您需要在Rust中知道的東西。

Rust提供兩種不同的型別來處理錯誤，分別是Option<T>和Result<T, E>。這兩種型別允許錯誤處理不同的案例，並提供使用者更容易的錯誤處理體驗。我們將探討如何處理錯誤和建立自己的錯誤型別。

從技術架構視角來看，Rust 的泛型和特徵系統展現了其在型別安全和程式碼重用方面的優勢。透過特徵約束泛型型別引數，Rust 編譯器可在編譯時確保型別安全，避免執行時期錯誤。同時，泛型允許開發者編寫適用於多種型別的程式碼，減少程式碼冗餘並提升可維護性。然而，過度使用泛型和特徵可能會增加程式碼的複雜度，對於簡單的應用場景，需權衡其必要性。

分析複數運算函式庫和 Archiver 結構的實作，可以發現 Rust 的所有權和借用系統在處理資料結構時如何確保記憶體安全。Archiver 的 push 和 pop 方法巧妙地利用所有權轉移和借用，避免了資料競爭和懸空指標等問題。此外，IntoIterator 特徵的實作展現了 Rust 迭代器模式的靈活性，方便使用者以不同的方式遍歷資料。但需注意，所有權和借用規則的理解和應用是 Rust 開發的關鍵挑戰，需要仔細設計和測試。

展望未來，Rust 的泛型和特徵系統將持續演進，例如 const generics 的發展將進一步提升程式碼的效能和靈活性。此外，Rust 社群也在積極探索更簡潔的語法和更強大的型別推導能力，以降低開發者的學習曲線。隨著 Rust 生態系統的日趨完善，我們預見其在效能敏感和安全要求高的領域將扮演越來越重要的角色。玄貓認為，Rust 的嚴謹性和安全性使其成為構建可靠且高效軟體系統的理想選擇，值得深入學習和應用。

玄貓

玄貓

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