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

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

不久前 Stackoverflow 網(wǎng)站做了一項(xiàng)有八萬多開發(fā)人員參與的調(diào)查問卷，在“大家最想學(xué)習(xí)的編程語言”選項(xiàng)中，Rust高居第一。

一、賦值的move語義

（一）C++ vs Rust

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

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

• 對于所有實(shí)現(xiàn)了Copy trait的類型來說，賦值采用了copy語義。

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

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

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

會產(chǎn)生編譯錯誤：

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的拷貝構(gòu)造函數(shù)來達(dá)到禁止變量復(fù)制的目的。如以下代碼是編譯不通過的：

#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++中會產(chǎn)生如下錯誤：

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進(jìn)行賦值時會產(chǎn)生coredump。這也是Rust所謂的內(nèi)存安全性，即只要沒有使用unsafe，編譯器可以發(fā)現(xiàn)內(nèi)存的錯誤訪問，并拒絕通過編譯。

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

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

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少實(shí)現(xiàn)了Copy和Clone。因此，對于可變引用&mut?T來說，賦值采用的是move語義，而對于普通引用&T來說采用的是copy語義，所以改成普通引用上面的程序就可以編譯通過了。

這也是為什么可變引用也被稱之為獨(dú)占引用，因?yàn)槊看螌勺円玫馁x值，都意味著舊變量的失效，這就確保了全局只會存在一份可變引用。

Rust在這里體現(xiàn)了語言設(shè)計(jì)的優(yōu)雅：賦值操作的語義委托到了類型系統(tǒng)，通過定義基本的機(jī)制同時約束了自定義類型與內(nèi)建類型的行為，在編譯期完成檢查，而不是需要開發(fā)去記憶各種特例。這在不了解語言的時候會產(chǎn)生學(xué)習(xí)曲線，但是一旦了解了其套路后（Thinking in Rust）， 可以顯著地降低編碼過程中的心智負(fù)擔(dān)。

二、Option與空指針

（一）enum與match

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

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

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

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

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

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

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

再編譯時會出現(xiàn)以下錯誤，提示開發(fā)將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++中，與其最相似的類型其實(shí)是C++17的std::variant，而match機(jī)制類似于std::visit。但Rust在這里做得更完善一些，體現(xiàn)在：

• 相同的子類型可以因?yàn)門ag的不同出現(xiàn)多次，如上面的Write和Send，子類型都是String。這是std::variant無法直接做到的，除非再封裝一個結(jié)構(gòu)。

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

（二）Option

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

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

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

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

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

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

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

相較于使用指針來表達(dá)可選情形，Option<T>的表達(dá)力會更豐富一些，因?yàn)闆]有強(qiáng)制將T轉(zhuǎn)成T*，保留了移動優(yōu)化的可能性；同時，使用專門的類型來表達(dá)可選，在語義上也理加精確一些。

了解Haskell的同學(xué)可以發(fā)現(xiàn)，Option與Maybe如出一轍。事實(shí)上，Rust的類型系統(tǒng)，很大程度地受到了Haskell的影響，所以很多地方可以看到Haskell的影子也并不奇怪。學(xué)習(xí)Haskell對理解Rust也會很有幫助。

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

三、迭代器Iterator

（一）Iterator在Rust中的地位

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

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

因?yàn)橄虬踩缘耐讌f(xié)，每次data[i]的操作都會進(jìn)行邊界檢查，顯然這種檢查是不必要的，在性能敏感的場景中也是不可接受的。因此，在Rust中推薦的做法是：

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

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

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

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

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

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

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

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

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

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

（三）IntoIterator

對于一般的迭代形式：

for x in data {}

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

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

這里for ... in語句使用IntoIterator::into_iter獲取了目標(biāo)對象的迭代器。因此，凡是實(shí)現(xiàn)了IntoIterator的類型均可以使用for ... in語句進(jìn)行迭代。

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

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

（四）鏈?zhǔn)秸{(diào)用

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

Adapter在Rust中指的是一類函數(shù)，它們接收一個Iterator并且返回一個Iterator。這樣的接口規(guī)范使用可以通過鏈?zhǔn)秸{(diào)用的方式組合多個Adapter完成復(fù)雜的功能。常見的Adapter包括：map、filter以及filter_map等等。

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

• count

用于計(jì)算元素的個數(shù)。

• collect

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

• reduce

使用某個函數(shù)對集合進(jìn)行規(guī)約。類似地，也可以使用fold進(jìn)行有初值的規(guī)約。

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

最后提一下，C++社區(qū)也在積極的采納此種代碼風(fēng)格，在C++20中，已經(jīng)將ranges加入標(biāo)準(zhǔn)。其中提供的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

最后需要提一下的是，對于使用鏈?zhǔn)秸{(diào)用的方式將各種Adapter組合的Iterator，其求值是惰性的。即，當(dāng)寫下如下代碼時：

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

其實(shí)并不會去調(diào)用println將數(shù)據(jù)輸出。Rust文檔的原文是：

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

即，只有調(diào)用迭代器的next方法，才會依次觸發(fā)各級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)會分別先執(zhí)行10次和5次，最后才是take(2)取到最開始的兩個元素。如果這個數(shù)組的長度不是10，而100萬，那么這里浪費(fèi)的空間和時間將會是巨大的。同時也會影響響應(yīng)時間，因?yàn)橹挥星懊鎯刹蕉继幚硗戤呏?#xff0c;才會進(jìn)行到最后一步。

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

（二）無限迭代

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

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

不會因?yàn)閒ilter(even)的調(diào)用而陷入死循環(huán)。而是按需取用。使用此種方法，可以使用遞推公式實(shí)現(xiàn)數(shù)列的迭代器, 并支持各種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);} }

五、總結(jié)

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

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

騰訊程序員今晚7點(diǎn)30分開播

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。