泛型 Generics泛型詳解

使用泛型參數(shù)，有一個先決條件，必需在使用前對其進行聲明：

fn largest<T>(list: &[T]) -> T {

該泛型函數(shù)的作用是從列表中找出最大的值，其中列表中的元素類型為 T。首先 largest<T> 對泛型參數(shù) T 進行了聲明，然后才在函數(shù)參數(shù)中進行使用該泛型參數(shù) list: &[T] 。

下面是一個錯誤的泛型函數(shù)的實現(xiàn)：

fn largest<T>(list: &[T]) -> T {let mut largest = list[0];for &item in list.iter() {if item > largest {largest = item;}}largest
}fn main() {let number_list = vec![34, 50, 25, 100, 65];let result = largest(&number_list);println!("The largest number is {}", result);let char_list = vec!['y', 'm', 'a', 'q'];let result = largest(&char_list);println!("The largest char is {}", result);
}

運行后報錯：

error[E0369]: binary operation `>` cannot be applied to type `T` // `>`操作符不能用于類型`T`--> src/main.rs:5:17|
5 |         if item > largest {|            ---- ^ ------- T|            ||            T|
help: consider restricting type parameter `T` // 考慮對T進行類型上的限制 :|
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {|             ++++++++++++++++++++++

因為 T 可以是任何類型，但不是所有的類型都能進行比較，因此上面的錯誤中，編譯器建議我們給 T 添加一個類型限制：使用 std::cmp::PartialOrd 特征（Trait）對 T 進行限制，特征在下一節(jié)會詳細介紹，現(xiàn)在你只要理解，該特征的目的就是讓類型實現(xiàn)可比較的功能。

結(jié)構(gòu)體中使用泛型

結(jié)構(gòu)體中的字段類型也可以用泛型來定義，下面代碼定義了一個坐標點 Point，它可以存放任何類型的坐標值：

struct Point<T> {x: T,y: T,
}fn main() {let integer = Point { x: 5, y: 10 };let float = Point { x: 1.0, y: 4.0 };
}

這里有兩點需要特別的注意：

提前聲明，跟泛型函數(shù)定義類似，首先我們在使用泛型參數(shù)之前必需要進行聲明 Point<T>，接著就可以在結(jié)構(gòu)體的字段類型中使用 T 來替代具體的類型
x 和 y 是相同的類型
第二點非常重要，如果使用不同的類型，那么它會導(dǎo)致下面代碼的報錯：

如果想讓 x 和 y 既能類型相同，又能類型不同，就需要使用不同的泛型參數(shù)：

struct Point<T,U> {x: T,y: U,
}
fn main() {let p = Point{x: 1, y :1.1};
}

切記，所有的泛型參數(shù)都要提前聲明.

枚舉中使用泛型

提到枚舉類型，Option 永遠是第一個應(yīng)該被想起來的，在之前的章節(jié)中，它也多次出現(xiàn)：

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

Option<T> 是一個擁有泛型 T 的枚舉類型，它第一個成員是 Some(T)，存放了一個類型為 T 的值。得益于泛型的引入，我們可以在任何一個需要返回值的函數(shù)中，去使用 Option<T> 枚舉類型來做為返回值，用于返回一個任意類型的值 Some(T)，或者沒有值 None。

enum Result<T, E> {Ok(T),Err(E),
}

這個枚舉和 Option 一樣，主要用于函數(shù)返回值，與 Option 用于值的存在與否不同，Result 關(guān)注的主要是值的正確性。

如果函數(shù)正常運行，則最后返回一個 Ok(T)，T 是函數(shù)具體的返回值類型，如果函數(shù)異常運行，則返回一個 Err(E)，E 是錯誤類型。例如打開一個文件：如果成功打開文件，則返回 Ok(std::fs::File)，因此 T 對應(yīng)的是 std::fs::File 類型；而當打開文件時出現(xiàn)問題時，返回 Err(std::io::Error)，E 對應(yīng)的就是 std::io::Error 類型。

方法中使用泛型

方法上也可以使用泛型：

struct Point<T> {x: T,y: T,
}impl<T> Point<T> {fn x(&self) -> &T {&self.x}
}
fn main() {let p = Point { x: 5, y: 10 };println!("p.x = {}", p.x());
}

使用泛型參數(shù)前，依然需要提前聲明：impl<T>，只有提前聲明了，我們才能在Point&ltT>中使用它，這樣 Rust 就知道 Point 的尖括號中的類型是泛型而不是具體類型。需要注意的是，這里的 Point&ltT> 不再是泛型聲明，而是一個完整的結(jié)構(gòu)體類型，因為我們定義的結(jié)構(gòu)體就是 Point&ltT> 而不再是 Point。

除了結(jié)構(gòu)體中的泛型參數(shù)，我們還能在該結(jié)構(gòu)體的方法中定義額外的泛型參數(shù)，就跟泛型函數(shù)一樣：

struct Point<T, U> {x: T,y: U,
}impl<T, U> Point<T, U> {fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {Point {x: self.x,y: other.y,}}
}fn main() {let p1 = Point { x: 5, y: 10.4 };let p2 = Point { x: "Hello", y: 'c'};let p3 = p1.mixup(p2);println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}

這個例子中，T,U 是定義在結(jié)構(gòu)體 Point 上的泛型參數(shù)，V,W 是單獨定義在方法 mixup 上的泛型參數(shù)，它們并不沖突，說白了，你可以理解為，一個是結(jié)構(gòu)體泛型，一個是函數(shù)泛型。

為具體的泛型類型實現(xiàn)方法

對于 Point<T> 類型，你不僅能定義基于 T 的方法，還能針對特定的具體類型，進行方法定義：

impl Point<f32> {fn distance_from_origin(&self) -> f32 {(self.x.powi(2) + self.y.powi(2)).sqrt()}
}

這段代碼意味著 Point<f32> 類型會有一個方法 distance_from_origin，而其他 T 不是 f32 類型的 Point<T> 實例則沒有定義此方法。這個方法計算點實例與坐標(0.0, 0.0) 之間的距離，并使用了只能用于浮點型的數(shù)學(xué)運算符。

const 泛型

const 泛型，也就是針對值的泛型，正好可以用于處理數(shù)組長度的問題：

fn display_array<T: std::fmt::Debug, const N: usize>(arr: [T; N]) {println!("{:?}", arr);
}
fn main() {let arr: [i32; 3] = [1, 2, 3];display_array(arr);let arr: [i32; 2] = [1, 2];display_array(arr);
}

如上所示，我們定義了一個類型為 [T; N] 的數(shù)組，其中 T 是一個基于類型的泛型參數(shù)，這個和之前講的泛型沒有區(qū)別，而重點在于 N 這個泛型參數(shù)，它是一個基于值的泛型參數(shù)！因為它用來替代的是數(shù)組的長度。

N 就是 const 泛型，定義的語法是 const N: usize，表示 const 泛型 N ，它基于的值類型是 usize。

在泛型參數(shù)之前，Rust 完全不適合復(fù)雜矩陣的運算，自從有了 const 泛型，一切即將改變。

const 泛型表達式

假設(shè)我們某段代碼需要在內(nèi)存很小的平臺上工作，因此需要限制函數(shù)參數(shù)占用的內(nèi)存大小，此時就可以使用 const 泛型表達式來實現(xiàn)：

// 目前只能在nightly版本下使用
#![allow(incomplete_features)]
#![feature(generic_const_exprs)]fn something<T>(val: T)
whereAssert<{ core::mem::size_of::<T>() < 768 }>: IsTrue,//       ^-----------------------------^ 這里是一個 const 表達式，換成其它的 const 表達式也可以
{//
}fn main() {something([0u8; 0]); // oksomething([0u8; 512]); // oksomething([0u8; 1024]); // 編譯錯誤，數(shù)組長度是1024字節(jié)，超過了768字節(jié)的參數(shù)長度限制
}// ---pub enum Assert<const CHECK: bool> {//
}pub trait IsTrue {//
}impl IsTrue for Assert<true> {//
}
const fn
@todo