作者：孟杰，騰訊 TEG后臺開發工程師

在日常開發過程中，若長期使用C++語言，在初次使用Rust的過程中可能會碰到一些問題。本文嘗試從C++的角度來說明在使用Rust時需要特別注意的一些地方，特別是其中的思維方式的轉變(mind shift)。

不久前 Stackoverflow 網站做了一項有八萬多開發人員參與的調查問卷，在“大家最想學習的編程語言”選項中，Rust高居第一。

一、賦值的move語義

（一）C++ vs Rust

C++的賦值操作是copy語義，在不考慮優化的情況下，從語義的角度理解，賦值后內存中的某個對象即變成了兩份。修改新的對象并不會對舊對象產生副作用。

而Rust對賦值操作有更加精細的控制，以下兩條：

• 對于所有實現了Copy trait的類型來說，賦值采用了copy語義。

• 對于其它情況，采用move語義。

在Rust中直接使用編譯器來保證了move語義，確保變量的值被移出后，不能被再使用，如下例：

fn main() {let mut x = 5;let rx0 = &mut x;let rx1 = rx0;println!("test {}", rx0); }

會產生編譯錯誤：

error[E0382]: borrow of moved value: `rx0`--> src/main.rs:5:25| 3 | let rx0 = &mut x;| --- move occurs because `rx0` has type `&mut i32`, which does not implement the `Copy` trait 4 | let rx1 = rx0;| --- value moved here 5 | println!("test {}", rx0);| ^^^ value borrowed here after move

明確地說明了原因：變量在移動后又被使用了，在哪兒被使用，以及為什么采用了move語義。

而在C++中，可以通過禁用class的拷貝構造函數來達到禁止變量復制的目的。如以下代碼是編譯不通過的：

#include <memory>using namespace std;int main(int argc, const char* argv[]) {auto int_p0 = unique_ptr<int>(new int);auto int_p1 = int_p0;*int_p0 = 5;return 0; }

在clang++中會產生如下錯誤：

main.cc:8:10: error: call to implicitly-deleted copy constructor of 'std::__1::unique_ptr<int, std::__1::default_delete<int> >'auto int_p1 = int_p0;^ ~~~~~~ /opt/llvm/clang-10.0.1/bin/../include/c++/v1/memory:2513:3: note: copy constructor is implicitly deleted because 'unique_ptr<int, std::__1::default_delete<int> >' has a user-declared move constructorunique_ptr(unique_ptr&& __u) _NOEXCEPT^

但是只需要將錯誤行改成如下代碼即可以編譯通過：

auto int_p1 = std::move(int_p0);

但后果是，程序在對*int_p0進行賦值時會產生coredump。這也是Rust所謂的內存安全性，即只要沒有使用unsafe，編譯器可以發現內存的錯誤訪問，并拒絕通過編譯。

（二）引用&T與可變引用&mut T

還是上面的例子，如果將其中的可變引用改成非可變引用（默認形式的引用），如下代碼：

fn main() {let x = 5;let rx0 = &x;let rx1 = rx0;println!("test {}", rx0); }

可以通過編譯。Rust的文檔中有如下說明：

The following traits are implemented for all &T, regardless of the type of its referent:Copy Clone (Note that this will not defer to T’s Clone implementation if it exists!) Deref Borrow Pointer*&mut T references get all of the above except Copy and Clone (to prevent creating multiple simultaneous mutable borrows), plus the following, regardless of the type of its referent:DerefMut BorrowMut

&mut T相較于&T少實現了Copy和Clone。因此，對于可變引用&mut?T來說，賦值采用的是move語義，而對于普通引用&T來說采用的是copy語義，所以改成普通引用上面的程序就可以編譯通過了。

這也是為什么可變引用也被稱之為獨占引用，因為每次對可變引用的賦值，都意味著舊變量的失效，這就確保了全局只會存在一份可變引用。

Rust在這里體現了語言設計的優雅：賦值操作的語義委托到了類型系統，通過定義基本的機制同時約束了自定義類型與內建類型的行為，在編譯期完成檢查，而不是需要開發去記憶各種特例。這在不了解語言的時候會產生學習曲線，但是一旦了解了其套路后（Thinking in Rust）， 可以顯著地降低編碼過程中的心智負擔。

二、Option與空指針

（一）enum與match

在C++中，對于可能存在或不存在的變量，慣常的作法之一是傳入指針 （包括現代C++中智能指針shared_ptr和unique_ptr），在處理時，通過檢查指針是否為空來判斷變量是否存在。這是一種非常便利的做法，但是同樣的，此方案在編譯期無法做更多的檢查，最終檢查的責任交給了開發。

Rust對此問題主要使用了兩個機制：枚舉(enum)和模式匹配(match)。相比較C++的enum, Rust的enum更像是C++的union。是 ADT(algebraic data type)中sum types(tagged union)在Rust中的實現。在Rust中enum可能包括一組類型中的一個，如：

enum Message {Quit,Move {x: i32, y: i32},Write (String), }

上面代碼表示，一條消息(Message)可能有三種類型: Quit、Move和Write。當類型為Move或者Write時，還可以帶上自己的特定的數據。當處理Message時，則會使用模式匹配機制取得具體類型進行處理：

match message {Message::Quit => todo!(),Message::Move { x, y } => todo!(),Message::Write(info) => todo!(), }

為了避免在修改了enum的定義后，忘記在match中添加相應的處理，match會在編譯期要求分支必須覆蓋全部可能的情況。如在Message中新加入一項：

enum Message {Quit,Move {x: i32, y: i32},Write (String),Send (String), // 新加入 }

再編譯時會出現以下錯誤，提示開發將Send的處理加入match。

--> src/main.rs:9:11| 1 | / enum Message { 2 | | Quit, 3 | | Move { x: i32, y: i32 }, 4 | | Write(String), 5 | | Send(String),| | ---- not covered 6 | | }| |_- `Message` defined here ... 9 | match message {| ^^^^^^^ pattern `Send(_)` not covered|= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms= note: the matched value is of type `Message`

由此可見，在C++中，與其最相似的類型其實是C++17的std::variant，而match機制類似于std::visit。但Rust在這里做得更完善一些，體現在：

• 相同的子類型可以因為Tag的不同出現多次，如上面的Write和Send，子類型都是String。這是std::variant無法直接做到的，除非再封裝一個結構。

• match會要求分支覆蓋enum所有變體，std::visit也會在編譯期檢查完整的類型覆蓋，但其中類型會考慮C++的隱式類型轉換，使用時需要小心。

（二）Option

有了上面的預備知識，現在就可以來了解在Rust中是如何處理空懸指針的問題。先看一下Option的定義：

pub enum Option<T> {/// No valueNone,/// Some value `T`Some(T), }

在Rust中，對于可選的情景，會定義為該變量類型的Option。假設某函數提供從磁盤讀取某個token，該token可能存在或者不存在，那么該函數的定義會是：

struct Token { /*...*/ };fn load_token() -> Option<Token>;

在使用的時候會采用如下代碼：

let token = load_token(); // 此時 token 的類型是 Option<Token>match token {Some(token) => {// 注意這里的 token 是由 Some(token) 這個 pattern 匹配出來的// 已經覆蓋了最外層的 token. 此時 token 的類型是 Token, 已經// 確保存在。todo!()},None => todo!() }

可以看到，對于返回Option<T>的情形，無法直接將Option<T>當作T來處理，只能使用模式匹配機制(match，if let，while let等)，將T提取出來處理。這一步強制的機制，確保了對可為空的變量進行檢查，避免了對空懸指針的意外訪問。

相較于使用指針來表達可選情形，Option<T>的表達力會更豐富一些，因為沒有強制將T轉成T*，保留了移動優化的可能性；同時，使用專門的類型來表達可選，在語義上也理加精確一些。

了解Haskell的同學可以發現，Option與Maybe如出一轍。事實上，Rust的類型系統，很大程度地受到了Haskell的影響，所以很多地方可以看到Haskell的影子也并不奇怪。學習Haskell對理解Rust也會很有幫助。

最后說明一下，在C++17中加入的std::optional實現了類似的功能。從接口上說還是像智能指針，使用前需要判斷，否則對std::nullopt進行dereference還是會產生運行時故障。

三、迭代器Iterator

（一）Iterator在Rust中的地位

Iterator是Rust相對獨特的功能。對于Rust來說，采用如下的方式去遍歷數組是低效的：

let data = vec![1,2,3,4,5];for i in 0..data.len() {println!("{}", data[i]); }

因為向安全性的妥協，每次data[i]的操作都會進行邊界檢查，顯然這種檢查是不必要的，在性能敏感的場景中也是不可接受的。因此，在Rust中推薦的做法是：

for v in data {println!("{}", v); }

使用迭代器的形式避免了最終取值時的再一次邊界檢查，同時也更加簡潔。由此可見，以地道的Rust風格來說，遍歷數組應該使用迭代器來完成，而不是通過遍歷下標來進行索引。

對于現代C++ (C++11)來說，也提供了類似的語法方式進行容器遍歷：

for (auto&& v: data) {// do something for v }

（二）取得迭代器的三種形式

對于可以迭代的對象，以std::vec::Vec為例，通常會提供三種方式取得迭代器，如下：

• iter()：取得元素的引用，即&T，非消耗性。

• iter_mut()：取得元素的可變引用，即&mut?T，非消耗性。

• into_iter()：取得元素的所有權，即T，消耗性。

這里消耗性指的是在迭代完成之后，原來的容器是否還可以繼續使用。對于into_iter()來說，在迭代過程中已經將容器中的所有元素所有權全部取得，所以最終容器不再持有任何對象，也同時被drop。因此稱之為消耗性的。

（三）IntoIterator

對于一般的迭代形式：

for x in data {}

Rust期望data是一個實現了Iterator的對象。否則，會嘗試使用IntoIterator將data轉換成`Iterator`對象。所以對于data: Vec<i32>來說，實際展開成了如下代碼：

for x in IntoIterator::into_iter(data) { }

這里for ... in語句使用IntoIterator::into_iter獲取了目標對象的迭代器。因此，凡是實現了IntoIterator的類型均可以使用for ... in語句進行迭代。

以std::vec::Vec為例，分別為Vec<T>、& Vec<T>和&mut Vec<T>實現了IntoIterator，并分別代理到into_iter()、iter()?和 iter_mut()，以應對上面所說的三種不同迭代形式。如下例（清晰起見，將類型注解加上了）：

let mut data: Vec<i32> = Vec::from([1,2,3,4]); // 取得引用 for v: &i32 in &data {} // 取得可變引用 for v: &mut i32 in &mut data {} // 取得所有權 for v: i32 in data {}

（四）鏈式調用

在Rust的設計中，利用Adapter可以靈活而高效地通過Iterator來處理集合。

Adapter在Rust中指的是一類函數，它們接收一個Iterator并且返回一個Iterator。這樣的接口規范使用可以通過鏈式調用的方式組合多個Adapter完成復雜的功能。常見的Adapter包括：map、filter以及filter_map等等。

除了Adapter，Rust也提供其它一些函數用于迭代器的最終處理。比如：

• count

用于計算元素的個數。

• collect

用于收集迭代器中的元素到某個實現了FromIterator的類型中去，比如Vec、VecDeque和String等等。

• reduce

使用某個函數對集合進行規約。類似地，也可以使用fold進行有初值的規約。

可以看到，針對迭代器，Rust提供了豐富的函數對其處理，具體可以參考文檔。此種編碼風格，與舊風格的C++很不一樣，轉到Rust后在需要對集合進行循環處理的場合，可以有意識地想想，能不能將邏輯寫成迭代器的形式，通常可以得到更加簡潔的代碼，同時，如前面所說，也可能獲得性能更高的代碼。

最后提一下，C++社區也在積極的采納此種代碼風格，在C++20中，已經將ranges加入標準。其中提供的Range adaptors與Rust的Adapter的概念基本是一樣的。如C++的樣例代碼：

auto const ints = {0,1,2,3,4,5};auto even = [](int i) { return 0 == i % 2; };auto square = [](int i) { return i * i; };// "pipe" syntax of composing the views:for (int i : ints | std::views::filter(even) | std::views::transform(square)) {std::cout << i << ' ';}

寫成Rust則是：

let ints = vec![0, 1, 2, 3, 4, 5];let even = |i: &i32| 0 == *i % 2;let square = |i: i32| i * i;for i in ints.into_iter().filter(even).map(square) {println!("{}", i);}

一、惰性求值-Laziness

最后需要提一下的是，對于使用鏈式調用的方式將各種Adapter組合的Iterator，其求值是惰性的。即，當寫下如下代碼時：

let v = vec![0,1,2,3,4,5]; v.iter().map(|i| println!("{}", i));

其實并不會去調用println將數據輸出。Rust文檔的原文是：

This means that just creating an iterator doesn’t do a whole lot. Nothing really happens until you call next

即，只有調用迭代器的next方法，才會依次觸發各級Iterator的求值。這樣做的好處是：

（一）性能

考慮如下代碼：

let v = vec![0,1,2,3,4,5,6,7,8,9]; let even = |i: &i32| 0 == *i % 2; let square = |i: i32| i * i; v.into_iter().filter(even).map(square).take(2);

如果是eager evaluation，前兩個Adapter，filter(even)和map(square)會分別先執行10次和5次，最后才是take(2)取到最開始的兩個元素。如果這個數組的長度不是10，而100萬，那么這里浪費的空間和時間將會是巨大的。同時也會影響響應時間，因為只有前面兩步都處理完畢之后，才會進行到最后一步。

而采用lazy evaluation時，執行會由take(2).next()傳導到map(square)再到filter(even), 最終不論數組的長度是多少，都只會調用filter(even)3次，map(square)2次。沒有產生額外的開銷。

（二）無限迭代

惰性求值的另一個好處是，使得無限迭代器成為了可能。考慮如下代碼：

let number = 1..; // 這是一個無限迭代器 for n in number.filter(even).take(5) {println!("{}", n) }

不會因為filter(even)的調用而陷入死循環。而是按需取用。使用此種方法，可以使用遞推公式實現數列的迭代器, 并支持各種Adapter的組合：

pub struct Fib {n0: u64,n1: u64, }impl Default for Fib {fn default() -> Self {Self { n0: 0, n1: 1 }} }impl Iterator for Fib {type Item = u64;fn next(&mut self) -> Option<Self::Item> {let n = self.n0 + self.n1;self.n0 = self.n1;self.n1 = n;Some(self.n0)} }fn main() {let fib = Fib::default();let square = |i: u64| i * i;for n in fib.map(square).take(10) {println!("{}", n);} }

五、總結

本文主要是記錄自己從C++轉向Rust碰到的一些問題，特別是記錄兩種語言在處理程序設計中基礎問題的不同套路。這一篇主要介紹了三個主題：move語義、Option和Iterator。由于筆者寫的Rust也不多，所以其中必然會有很多錯誤與不足，發出來與大家交流，希望大家包涵并不吝指教。

之后也會以同樣的形式介紹其它主題，比如當前心里還想著要記錄的有：錯誤處理、生命周期&借用、interior mutability等。接下來自己爭取將后面的系列完成。

騰訊程序員今晚7點30分開播

總結

以上是生活随笔為你收集整理的从C++转向最受欢迎的Rust语言的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。