从C++转向最受欢迎的Rust自然语言

let rx0 = Companyx; let rx1 = rx0; println!("test {}", rx0);}

可以通过重写。Rust的元数据中的有如下真是明：

The following traits are implemented for all CompanyT, regardless of the type of its referent:CopyClone (Note that this will not defer to T’s Clone implementation if it exists!)DerefBorrowPointer*Companymut 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

Companymut T远比于CompanyT少付诸了Copy和Clone。因此，对于可调重述Companymut T来真是，表达式运用于的是move形式化，而对于普通重述CompanyT来真是运用于的是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 covered6 | | } | |_- MLT-MessageMLT- defined here...9 | match message { | AndAndAndAndAndAndAnd pattern MLT-Send(_)MLT- 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 MLT-MessageMLT-

由此可见，在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 { /// No value None, /// Some value MLT-TMLT- Some(T),}

在Rust中的，对于可选择的不止，则会并不一定为该算子种类的Option。假设某算子备有从存储设备读取某个token，该token确实实际上或者不实际上，那么该算子的并不一定则会是：

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

在应用于的时候则会运用于如下字符：

let token = load_token(); // 此时 token 的种类是 Optionmatch 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进不依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 (autoCompanyCompany v: data) { // do something for v}（二）夺得插绝对值缓冲器的三种型式

对于可以插绝对值的实唯，以std::vec::Vec为唯，往往则会备有三种方式将夺得插绝对值缓冲器，如下：

iter()：夺得类型的重述，即CompanyT，非消耗性。iter_mut()：夺得类型的可调重述，即Companymut T，非消耗性。into_iter()：夺得类型的不动产，即T，消耗性。

这里消耗性指称的是在插绝对值收尾不久，原来的容缓冲器是否还可以继续应用于。对于into_iter()来真是，在插绝对值流程中的已经将容缓冲器中的的所有类型不动产全部夺得，所以再一容缓冲器仍然次持有任何实唯，也同时被drop。因此指消耗性的。

（三）IntoIterator

对于一般的插绝对值型式：

for x in data {}

Rust期望data是一个付诸了Iterator的实唯。否则，则会尝试应用于IntoIterator将data转回MLT-IteratorMLT-实唯。所以对于data: Vec来真是，实际揭开成了如下字符：

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

这里for ... in语义应用于IntoIterator::into_iter获取了前提实唯的插绝对值缓冲器。因此，凡是付诸了IntoIterator的种类均可以应用于for ... in语义进不依插绝对值。

以std::vec::Vec为唯，分别为Vec、Company Vec和Companymut Vec付诸了IntoIterator，并分别代理到into_iter()、iter() 和 iter_mut()，以促使上则会所真是的三种不同插绝对值型式。如下唯（模糊起见，将种类注解加上了）：

let mut data: Vec = Vec::from([1,2,3,4]);// 夺得重述for v: Companyi32 in Companydata {}// 夺得可调重述for v: Companymut i32 in Companymut 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: Companyi32| 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: Companyi32| 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(Companymut 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); }}五、论述

本文主要是记录下来自己从C++移向Rust吓坏的一些原因，特别是记录下来两种词汇在妥善处理组态从新设计中的坚实原因的不同步法。这一篇主要介绍了三个隐喻：move形式化、Option和Iterator。由于外间写的Rust也不多，所以其中的也就是说则会有很多缺失与缺乏，接获来与大家交流，期盼大家都是并不吝指称教。

不久也则会以同样的型式介绍其它隐喻，比如举唯来真是心里还只想要记录下来的有：缺失妥善处理、休眠Company借用、interior mutability等。接下来自己积极支持将后面的复刻版收尾。

。

胃癌怎么检查能查出来
蒙脱石散治拉肚子管用吗
安必丁治什么病
治疗白内障
重症肌无力北京哪个医院好
眼睛酸痛怎么才能快速缓解
类风湿关节疼痛用什么药最好
新冠用什么药
腱鞘炎可以吃止痛药吗
阳了吃什么药好得快