當(dāng)大家一路看到這里時(shí)，我敢說 90% 的人還是云里霧里的，例如你能說清楚:

• 切片和切片引用的區(qū)別嗎？
• 各種字符串之間的區(qū)別嗎？
• 各種指針、引用的區(qū)別嗎？
• 所有權(quán)轉(zhuǎn)移、拷貝、克隆的區(qū)別嗎？

切片和切片引用

關(guān)于 str / &str，[u8] / &[u8] 區(qū)別，你能清晰的說出來嘛？如果答案是 No ，那就跟隨我一起來看看切片和切片引用到底有何區(qū)別吧。

在繼續(xù)之前，查看這里了解何為切片

切片允許我們引用集合中部分連續(xù)的元素序列，而不是引用整個(gè)集合。例如，字符串切片就是一個(gè)子字符串，數(shù)組切片就是一個(gè)子數(shù)組。

無法被直接使用的切片類型

Rust 語言特性內(nèi)置的 str 和 [u8] 類型都是切片，前者是字符串切片，后者是數(shù)組切片，下面我們來嘗試下使用 str ：

let string: str = "banana";

上面代碼創(chuàng)建一個(gè) str 類型的字符串，看起來很正常，但是編譯就會(huì)報(bào)錯(cuò)：

error[E0277]: the size for values of type `str` cannot be known at compilation time
 --> src/main.rs:4:9
  |
4 |     let string: str = "banana";
  |         ^^^^^^ doesn't have a size known at compile-time

編譯器準(zhǔn)確的告訴了我們?cè)颍簊tr 字符串切片它是 DST 動(dòng)態(tài)大小類型，這意味著編譯器無法在編譯期知道 str 類型的大小，只有到了運(yùn)行期才能動(dòng)態(tài)獲知，這對(duì)于強(qiáng)類型、強(qiáng)安全的 Rust 語言來說是不可接受的。

也就是說，我們無法直接使用 str，而對(duì)于 [u8] 也是類似的，大家可以自己動(dòng)手試試。

總之，我們可以總結(jié)出一個(gè)結(jié)論：在 Rust 中，所有的切片都是動(dòng)態(tài)大小類型，它們都無法直接被使用。

為何切片是動(dòng)態(tài)大小類型

原因在于底層的切片長度是可以動(dòng)態(tài)變化的，而編譯器無法在編譯期得知它的具體的長度，因此該類型無法被分配在棧上，只能分配在堆上。

為何切片只能通過引用來使用

既然切片只能分配到堆上，我們就無法直接使用它，大家可以想想，所有分配在堆上的數(shù)據(jù)，是不是都是通過一個(gè)在棧上的引用來訪問的？切片也不例外。

為何切片引用可以存儲(chǔ)在棧上

切片引用是一個(gè)寬指針，存儲(chǔ)在棧上，指向了堆上的切片數(shù)據(jù)，該引用包含了切片的起始位置和長度，而且最重要的是，類似于指針，引用的大小是固定的(起始位置和長度都是整形)，因此它才可以存儲(chǔ)在棧上。

有沒有可以存儲(chǔ)在棧上的

有，使用固定長度的數(shù)組: let a: [i8;4] = [1,2,3,4];，注意看，數(shù)組的類型與切片是不同的，前者的類型帶有長度：[i8;4]，而后者僅僅是 [i8]。

切片引用

那么問題來了，該如何使用切片呢？

何以解憂，唯有引用。由于引用類型的大小在編譯期是已知的，因此在 Rust 中，如果要使用切片，就必須要使用它的引用。

str 切片的引用類型是 &str，而 [i32] 的引用類型是 &[i32]，相信聰明的讀者已經(jīng)看出來了，&str和 &[i32] 都是我們非常常用的類型，例如:

let s1: &str = "banana";
let s2: &str = &String::from("banana");

let arr = [1, 2, 3, 4, 5];

let s3: &[i32] = &arr[1..3];

這段代碼就可以正常通過，原因在于這些切片引用的大小在編譯器都是已知的。

總結(jié)

我們常常說使用切片，實(shí)際上我們?cè)谟玫氖乔衅囊?，我們也在頻繁說使用字符串，實(shí)際上我們?cè)谑褂玫囊彩亲址衅囊谩?/p>

總之，切片在 Rust 中是動(dòng)態(tài)大小類型 DST，是無法被我們直接使用的，而我們?cè)谑褂玫亩际乔衅囊谩?/p>

但是出于方便，我們往往不會(huì)說使用切片引用，而是直接說使用字符串切片或數(shù)組切片，實(shí)際上，這時(shí)指代的都是切片的引用！

Eq 和 PartialEq

在 Rust 中，想要重載操作符，你就需要實(shí)現(xiàn)對(duì)應(yīng)的特征。

例如 <、<=、> 和 >= 需要實(shí)現(xiàn) PartialOrd 特征:

use std::fmt::Display;

struct Pair<T> {
    x: T,
    y: T,
}

impl<T> Pair<T> {
    fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
}

impl<T: Display + PartialOrd> Pair<T> {
    fn cmp_display(&self) {
        if self.x >= self.y {
            println!("The largest member is x = {}", self.x);
        } else {
            println!("The largest member is y = {}", self.y);
        }
    }
}

再比如， + 號(hào)需要實(shí)現(xiàn) std::ops::Add 特征，而本文的主角 Eq 和 PartialEq 正是 == 和 != 所需的特征，那么問題來了，這兩個(gè)特征有何區(qū)別？

我相信很多同學(xué)都說不太清楚，包括一些老司機(jī)，而且就算是翻文檔，可能也找不到特別明確的解釋。如果大家看過標(biāo)準(zhǔn)庫示例，可能會(huì)看過這個(gè)例子：

enum BookFormat { Paperback, Hardback, Ebook }
struct Book {
    isbn: i32,
    format: BookFormat,
}
impl PartialEq for Book {
    fn eq(&self, other: &Self) -> bool {
        self.isbn == other.isbn
    }
}
impl Eq for Book {}

這里只實(shí)現(xiàn)了 PartialEq，并沒有實(shí)現(xiàn) Eq，而是直接使用了默認(rèn)實(shí)現(xiàn) impl Eq for Book {}，奇了怪了，別急，還有呢：

impl PartialEq<IpAddr> for Ipv4Addr {
    #[inline]
    fn eq(&self, other: &IpAddr) -> bool {
        match other {
            IpAddr::V4(v4) => self == v4,
            IpAddr::V6(_) => false,
        }
    }
}

impl Eq for Ipv4Addr {}

以上代碼來自 Rust 標(biāo)準(zhǔn)庫，可以看到，依然是這樣使用，類似的情況數(shù)不勝數(shù)。既然如此，是否說明如果要為我們的類型增加相等性比較，只要實(shí)現(xiàn) PartialEq 即可？

其實(shí)，關(guān)鍵點(diǎn)就在于 partial 上，如果我們的類型只在部分情況下具有相等性，那你就只能實(shí)現(xiàn) PartialEq，否則可以實(shí)現(xiàn) PartialEq 然后再默認(rèn)實(shí)現(xiàn) Eq。

好的，問題逐步清晰起來，現(xiàn)在我們只需要搞清楚何為部分相等。

部分相等性

首先我們需要找到一個(gè)類型，它實(shí)現(xiàn)了 PartialEq 但是沒有實(shí)現(xiàn) Eq（你可能會(huì)想有沒有反過來的情況？當(dāng)然沒有啦，部分相等肯定是全部相等的子集?。?/p>

在 HashMap 章節(jié)提到過 HashMap 的 key 要求實(shí)現(xiàn) Eq 特征，也就是要能完全相等，而浮點(diǎn)數(shù)由于沒有實(shí)現(xiàn) Eq ，因此不能用于 HashMap 的 key。

當(dāng)時(shí)由于一些知識(shí)點(diǎn)還沒有介紹，因此就沒有進(jìn)一步展開，那么讓我們考慮浮點(diǎn)數(shù)既然沒有實(shí)現(xiàn) Eq 為何還能進(jìn)行比較呢？

fn main() {
   let f1 = 3.14;
   let f2 = 3.14;

   if f1 == f2 {
       println!("hello, world!");
   }
}

以上代碼是可以看到輸出內(nèi)容的，既然浮點(diǎn)數(shù)沒有實(shí)現(xiàn) Eq 那說明它實(shí)現(xiàn)了 PartialEq，一起寫個(gè)簡單代碼驗(yàn)證下：

fn main() {
    let f1 = 3.14;
    is_eq(f1);
    is_partial_eq(f1)
}

fn is_eq<T: Eq>(f: T) {}
fn is_partial_eq<T: PartialEq>(f: T) {}

上面的代碼通過特征約束的方式驗(yàn)證了我們的結(jié)論: 

3 |     is_eq(f1);
  |     ----- ^^ the trait `Eq` is not implemented for `{float}`

好的，既然我們成功找到了一個(gè)類型實(shí)現(xiàn)了 PartialEq 但沒有實(shí)現(xiàn) Eq，那就通過它來看看何為部分相等性。

其實(shí)答案很簡單，浮點(diǎn)數(shù)有一個(gè)特殊的值 NaN，它是無法進(jìn)行相等性比較的:

fn main() {
    let f1 = f32::NAN;
    let f2 = f32::NAN;

    if f1 == f2 {
        println!("NaN 竟然可以比較，這很不數(shù)學(xué)??！")
    } else {
        println!("果然，雖然兩個(gè)都是 NaN ，但是它們其實(shí)并不相等")
    }
}

大家猜猜哪一行會(huì)輸出 :) 至于 NaN 為何不能比較，這個(gè)原因就比較復(fù)雜了( 有讀者會(huì)說，其實(shí)就是你不知道，我只能義正嚴(yán)辭的說：咦？你怎么知道 :P )。

既然浮點(diǎn)數(shù)有一個(gè)值不可以比較相等性，那它自然只能實(shí)現(xiàn) PartialEq 而不能實(shí)現(xiàn) Eq 了，以此類推，如果我們的類型也有這種特殊要求，那也應(yīng)該這么作。

Ord 和 PartialOrd

事實(shí)上，還有一對(duì)與 Eq/PartialEq 非常類似的特征，它們可以用于 <、<=、> 和 >= 比較，至于哪個(gè)類型實(shí)現(xiàn)了 PartialOrd 卻沒有實(shí)現(xiàn) Ord 就交給大家自己來思考了：）

瘋狂字符串

字符串讓人瘋狂，這句話用在 Rust 中一點(diǎn)都不夸張，不信？那你能否清晰的說出 String、str、&str、&String、Box<str> 或 Box<&str> 的區(qū)別？

Rust 語言的類型可以大致分為兩種：基本類型和標(biāo)準(zhǔn)庫類型，前者是由語言特性直接提供的，而后者是在標(biāo)準(zhǔn)庫中定義。即將登場的 str 類型就是唯一定義在語言特性中的字符串。

在繼續(xù)之前，大家需要先了解字符串的基本知識(shí)，本文主要在于概念對(duì)比，而不是字符串講解

str

如上所述，str 是唯一定義在 Rust 語言特性中的字符串，但是也是我們幾乎不會(huì)用到的字符串類型，為何？

原因在于 str 字符串它是 DST 動(dòng)態(tài)大小類型，這意味著編譯器無法在編譯期知道 str 類型的大小，只有到了運(yùn)行期才能動(dòng)態(tài)獲知，這對(duì)于強(qiáng)類型、強(qiáng)安全的 Rust 語言來說是不可接受的。

let string: str = "banana";

上面代碼創(chuàng)建一個(gè) str 類型的字符串，看起來很正常，但是編譯就會(huì)報(bào)錯(cuò)：

error[E0277]: the size for values of type `str` cannot be known at compilation time
 --> src/main.rs:4:9
  |
4 |     let string: str = "banana";
  |         ^^^^^^ doesn't have a size known at compile-time

如果追求更深層的原因，我們可以總結(jié)如下：所有的切片都是動(dòng)態(tài)類型，它們都無法直接被使用，而 str就是字符串切片，[u8] 是數(shù)組切片。

同時(shí)還是 String 和 &str 的底層數(shù)據(jù)類型。由于 str 是動(dòng)態(tài)

str 類型是硬編碼進(jìn)可執(zhí)行文件，也無法被修改，但是 String 則是一個(gè)可增長、可改變且具有所有權(quán)的 UTF-8 編碼字符串，當(dāng) Rust 用戶提到字符串時(shí)，往往指的就是 String 類型和 &str 字符串切片類型，這兩個(gè)類型都是 UTF-8 編碼。

除了 String 類型的字符串，Rust 的標(biāo)準(zhǔn)庫還提供了其他類型的字符串，例如 OsString， OsStr， CsString 和 CsStr 等，注意到這些名字都以 String 或者 Str 結(jié)尾了嗎？它們分別對(duì)應(yīng)的是具有所有權(quán)和被借用的變量。

在 Rust 中，作用域、生命周期和 NLL（Non-Lexical Lifetimes，非詞法生命周期）是與內(nèi)存管理和借用系統(tǒng)密切相關(guān)的概念。

1. 作用域（Scopes）：

   在 Rust 中，每個(gè)變量都有自己的作用域，也就是變量的有效范圍。作用域可以是一個(gè)代碼塊（使用花括號(hào) `{}` 包圍的代碼段）或一個(gè)函數(shù)。當(dāng)變量超出其作用域時(shí)，它將被銷毀并釋放其占用的內(nèi)存。這種方式確保了資源的正確釋放，避免了常見的內(nèi)存泄漏和懸垂指針問題。

2. 生命周期（Lifetimes）：

   生命周期是 Rust 中用于管理借用的機(jī)制。當(dāng)一個(gè)變量借用另一個(gè)變量時(shí)，編譯器需要確保借用的變量在使用期間保持有效。生命周期注解（通常表示為 `'a`、`'b` 等）用于指定變量之間的依賴關(guān)系，以確保借用的有效性。生命周期注解描述了變量的最小有效范圍，編譯器使用它來進(jìn)行靜態(tài)分析和驗(yàn)證。

3. NLL（Non-Lexical Lifetimes）：

 NLL 是 Rust 編譯器

在 Rust 中，`move`、`Copy` 和 `Clone` 是與變量所有權(quán)和復(fù)制相關(guān)的關(guān)鍵概念。

1. `move`：

   當(dāng)將一個(gè)值賦值給另一個(gè)變量或?qū)⑵渥鳛楹瘮?shù)參數(shù)傳遞時(shí)，Rust 會(huì)默認(rèn)移動(dòng)（move）該值的所有權(quán)。移動(dòng)操作將轉(zhuǎn)移變量的所有權(quán)，原始變量將無法再訪問該值。這種方式避免了資源的重復(fù)釋放和懸垂指針問題。移動(dòng)操作常見于將所有權(quán)轉(zhuǎn)移到函數(shù)中或從一個(gè)作用域轉(zhuǎn)移到另一個(gè)作用域。

2. `Copy`：

   `Copy` 是一個(gè) trait（特質(zhì)），用于標(biāo)記可以通過簡單的位拷貝來復(fù)制的類型。當(dāng)一個(gè)類型實(shí)現(xiàn)了 `Copy`，它的值可以在賦值或傳遞給函數(shù)時(shí)進(jìn)行隱式的復(fù)制，而不會(huì)轉(zhuǎn)移所有權(quán)。`Copy` 類型的特點(diǎn)是在賦值或傳遞時(shí)不會(huì)發(fā)生所有權(quán)轉(zhuǎn)移，因此原始變量仍然可以訪問該值。常見的 `Copy` 類型包括整數(shù)、布爾值、浮點(diǎn)數(shù)以及一些固定大小的結(jié)構(gòu)體和枚舉。

3. `Clone`：

   `Clone` 也是一個(gè) trait，用于標(biāo)記可以通過顯式克隆來復(fù)制的類型。與 `Copy` 不同，`Clone` 的復(fù)制是顯式的，需要調(diào)用 `clone()` 方法來創(chuàng)建一個(gè)新的拷貝。`Clone` 適用于需要深度復(fù)制的類型，它可以在需要時(shí)創(chuàng)建一個(gè)值的獨(dú)立拷貝，而不是共享相同的底層數(shù)據(jù)。需要注意的是，并非所有類型都實(shí)現(xiàn)了 `Clone`，因?yàn)樯疃葟?fù)制可能涉及復(fù)雜的操作。

在 Rust 中，`move`、`Copy` 和 `Clone` 的使用取決于變量的所有權(quán)和復(fù)制需求。通過合理地使用這些概念，可以確保代碼的所有權(quán)轉(zhuǎn)移和復(fù)制操作是正確且高效的。

在 Rust 中，裸指針、引用和智能指針是用于處理內(nèi)存和所有權(quán)的不同工具。

1. 裸指針（Raw Pointers）：

   裸指針是直接操作內(nèi)存地址的指針，沒有 Rust 的安全保證。在 Rust 中，裸指針分為不可變裸指針（`*const T`）和可變裸指針（`*mut T`）。裸指針可以用于以下情況：

   - 與外部代碼（如 C 代碼）進(jìn)行交互。

   - 訪問未初始化的內(nèi)存區(qū)域。

   - 實(shí)現(xiàn)某些不安全的數(shù)據(jù)結(jié)構(gòu)和算法。

   使用裸指針需要謹(jǐn)慎，因?yàn)樗鼈兝@過了 Rust 的所有權(quán)和借用系統(tǒng)，容易導(dǎo)致內(nèi)存安全問題。

2. 引用（References）：

   引用是 Rust 中的安全指針，用于借用值而不獲取其所有權(quán)。引用分為不可變引用（`&T`）和可變引用（`&mut T`）。引用具有以下特點(diǎn)：

   - 引用是非空且始終有效的。

   - 引用遵循 Rust 的借用規(guī)則，保證了內(nèi)存安全性。

   - 引用在編譯時(shí)檢查，不會(huì)導(dǎo)致運(yùn)行時(shí)開銷。

   引用是 Rust 中常用的機(jī)制，用于實(shí)現(xiàn)借用檢查和避免數(shù)據(jù)競爭。

3. 智能指針（Smart Pointers）：

   智能指針是包裝了堆上數(shù)據(jù)的結(jié)構(gòu)，提供了額外的功能和語義。在 Rust 中，常見的智能指針有 `Box<T>`、`Rc<T>` 和 `Arc<T>`：

   - `Box<T>` 是在堆上分配內(nèi)存并擁有唯一所有權(quán)的指針。

   - `Rc<T>` 是引用計(jì)數(shù)智能指針，可以在多個(gè)位置共享所有權(quán)。

   - `Arc<T>` 是原子引用計(jì)數(shù)智能指針，適用于并發(fā)環(huán)境。

   智能指針提供了內(nèi)存管理、所有權(quán)傳遞、生命周期擴(kuò)展和特定行為的能力，可以用于解決特定的問題和場景。

總結(jié)：裸指針用于低級(jí)別的操作，引用用于安全的借用，智能指針提供了更高級(jí)別的內(nèi)存管理和所有權(quán)控制。在 Rust 中，推薦使用引用和智能指針來確保內(nèi)存安全性和代碼可維護(hù)性。