从C++到Rust：编程思维转变与赋值语义的深入解析

在日常开发过程中，如果你长期使用C++语言，第一次使用Rust时可能会遇到一些问题。本文试图从C++的角度解释一下使用Rust时需要特别注意的一些事情，尤其是思维方式的改变（mind shift）。

不久前，Stackoverflow网站进行了一项涉及超过8万名开发者的调查。在“大家最想学的编程语言”选项中，Rust 排名第一。

1. 赋值的移动语义（1）C++ vs Rust

C++的赋值操作使用复制语义。在不考虑优化的情况下，从语义的角度来看，内存中的一个对象在赋值后就变成了两份。修改新对象不会对旧对象产生任何副作用。

Rust 对赋值操作有更细粒度的控制，如下：

在Rust中，直接使用编译器来保证移动语义，保证变量的值移出后不能再次使用，如下例：

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` trait4 |     let rx1 = rx0;  |               --- value moved here5 |     println!("test {}", rx0);  |                         ^^^ value borrowed here after move

清楚地解释为什么：变量被移动后再次使用，在哪里使用，以及为什么使用移动语义。

在 C++ 中，您可以通过禁用类的复制构造函数来禁用变量复制。例如，以下代码未通过编译：

#include 
using namespace std;
int main(int argc, const char* argv[]) {    auto int_p0 = unique_ptr(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 >'    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 >' has a user-declared move constructor  unique_ptr(unique_ptr&& __u) _NOEXCEPT  ^

但只需要将错误行改为如下代码即可编译通过：

auto int_p1 = std::move(int_p0);

但后果是程序在赋值*int_p0时会产生coredump。这也是Rust所说的内存安全，即只要不使用unsafe，编译器就可以检测到对内存的错误访问并拒绝编译。

(2) 引用&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:
CopyClone (Note that this will not defer to T’s Clone implementation if it exists!)DerefBorrowPointer
*&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:
DerefMutBorrowMut

&mut T 比 &T 实现更少的复制和克隆。因此，对于变量引用&mutT，赋值采用移动语义，而对于普通引用&T，采用复制语义，因此，如果改为普通引用，上述程序可以编译通过。

这就是为什么可变引用也被称为独占引用，因为对可变引用的每次赋值都意味着旧变量的失效，这确保了世界上只会有一个可变引用。

Rust在这里体现了语言设计的优雅：赋值操作的语义被委托给类型系统，通过定义一个基本机制同时约束自定义类型和内置类型的行为。检查在编译时完成，而不需要开发人员记住每种类型。一个特例。当你不理解该语言时，这会产生一个学习曲线，但是一旦你理解了它的例程（Thinking in Rust），它可以显着减少编码过程中的精神负担。

2、Option与空指针（一）枚举与匹配

在C++中，对于可能存在或可能不存在的变量，常见的做法之一是传入一个指针（包括现代C++中的智能指针shared_ptr和unique_ptr），在处理时通过检查指针是否为null来判断变量是否存在。这是一种非常方便的做法，但同样，该解决方案无法在编译期间进行更多检查，最终的检查责任交给了开发人员。

Rust 主要使用两种机制来解决这个问题：枚举和模式匹配。与 C++ 的枚举相比，Rust 的枚举更像是 C++ 的 union。它是 Rust 中 ADT（代数数据类型）中求和类型（标记联合）的实现。在 Rust 中，枚举可能包含一组类型中的一个，例如：

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处理来匹配。

 --> src/main.rs:9:11  |1 | / enum Message {2 | |     Quit,3 | |     Move { x: i32, y: i32 },4 | |     Write(String),5 | |     Send(String),  | |     ---- not covered6 | | }  | |_- `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，匹配机制与std::visit类似。但 Rust 在这方面做得更好，如下所示：

(2) 选项

有了上面的初步知识，你现在可以了解如何处理 Rust 中的悬空指针问题了。我们先看一下Option的定义：

pub enum Option {    /// No value    None,    /// Some value `T`    Some(T),}

在 Rust 中，对于可选情况，Option 被定义为变量类型。假设一个函数提供从磁盘读取某个令牌。令牌可能存在也可能不存在，那么函数的定义将是：

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

使用时会用到如下代码：

let token = load_token(); // 此时 token 的类型是 Option
match token {  Some(token) => {    // 注意这里的 token 是由 Some(token) 这个 pattern 匹配出来的    // 已经覆盖了最外层的 token. 此时 token 的类型是 Token, 已经    // 确保存在。    todo!()  },  None => todo!()}

可以看到，Option返回时，不能直接将Option当做T，而是只能利用模式匹配机制（match、if let、while let等）将T提取出来并进行处理。这种强制机制可确保检查可为空变量并避免意外访问悬空指针。

与使用指针表达可选情况相比，Option更具表现力，因为它不强制T转换为T*，保留了移动优化的可能性；同时，使用特殊类型来表达可选情况。语义也应该更加精确。

了解Haskell的同学可以发现Option和Maybe是完全一样的。事实上，Rust 的类型系统深受 Haskell 的影响，所以在很多地方都能看到 Haskell 的身影也就不足为奇了。学习 Haskell 也有助于理解 Rust。

最后，C++17中添加的std::Optional实现了类似的功能。从接口上来看，它仍然像一个智能指针，在使用之前需要进行判断，否则解引用std::nullopt仍然会导致运行时失败。

3.Iterator（一）Iterator在Rust中的地位

迭代器是 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}

(2) 获取迭代器的三种形式

对于可迭代的对象，以std::vec::Vec为例，通常有以下三种方式获取迭代器：

这里的消耗是指迭代完成后原来的容器是否还能继续使用。对于into_iter()来说，在迭代过程中已经获得了容器中所有元素的所有权，所以最终容器不再持有任何对象，同时被丢弃。因此，它被称为消耗品。

(3) 进入迭代器

对于一般迭代形式：

for x in data {}

Rust 期望数据是一个实现 Iterator 的对象。否则，将尝试使用 IntoIterator 将数据转换为“Iterator”对象。那么对于data:Vec，它实际上展开为如下代码：

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

这里的 for...in 语句使用 IntoIterator::into_iter 来获取目标对象的迭代器。因此，任何实现 IntoIterator 的类型都可以使用 for...in 语句进行迭代。

以std::vec::Vec为例，IntoIterator分别针对Vec、&Vec和&mut Vec实现，并分别代理到into_iter()、iter()和iter_mut()来应对上面提到的三种不同的迭代。形式。这是一个示例（为了清楚起见添加了类型注释）：

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

(4) 链式调用

在Rust的设计中，Adapters可以通过Iterators来灵活高效地处理集合。

Rust 中的 Adapter 指的是一种接收 Iterator 并返回 Iterator 的函数类型。这样的接口规范可以通过链式调用的方式组合多个Adapter来完成复杂的功能。常见的Adapter有：map、filter、filter_map等。

除了Adapter之外，Rust还提供了一些其他函数用于迭代器的最终处理。例如：

用于计算元素的数量。

用于将迭代器中的元素收集成实现FromIterator的类型，例如Vec、VecDeque、String等。

使用函数来减少集合。同样，您也可以使用折叠来对初始值进行归约。

正如你所看到的，Rust 提供了丰富的函数来处理迭代器。详细信息请参阅文档。这种编码风格与旧的C++风格有很大不同。改用 Rust 后，当需要循环遍历集合时，可以有意识地思考是否可以将逻辑写成迭代器的形式，通常可以获得更简洁的代码。代码，同时，如前所述，也可以获得性能更高的代码。

最后，我想提一下，C++ 社区也在积极采用这种编码风格。在 C++20 中，范围已添加到标准中。提供的 Range 适配器与 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);  }

1.惰性评估-Lazyness

最后需要提到的是，使用链式调用组合各种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方法，才会依次触发各级迭代器的求值。这样做的好处是：

(一)性能

考虑以下代码：

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);

如果是eagervaluation，前两个Adapter，filter(even)和map(square)会分别执行10次和5次，最后take(2)获取前两个元素。如果这个数组的长度不是10，而是100万，那么这里浪费的空间和时间将会是巨大的。它还会影响响应时间，因为只有在处理完前两步后才会到达最后一步。

当使用惰性计算时，执行将从take(2).next()到map(square)，然后到filter(even)。最终，无论数组长度是多少，filter(even)都只会被调用3次。地图（正方形）2次。不会产生额外的开销。

(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 {    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);  }}