diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 2df4c74b..eebc9709 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -40,7 +40,7 @@ - [泛型Generics](basic/trait/generic.md) - [特征Trait](basic/trait/trait.md) - [特征对象](basic/trait/trait-object.md) - - [进一步了解特征 todo](basic/trait/advance-trait.md) + - [进一步深入特征](basic/trait/advance-trait.md) - [类型转换 todo](basic/type-converse.md) - [返回、异常和错误(todo)](basic/exception-error.md) @@ -164,6 +164,7 @@ - [过程宏(todo)](macro/procedure-macro.md) - [性能调优 todo](performance/intro.md) + - [糟糕的提前优化](performance/early-optimise.md) - [Clone和Copy](performance/clone-copy.md) - [Benchmark性能测试(todo)](performance/benchmark.md) - [减少Runtime check(todo)](performance/runtime-check.md) @@ -195,6 +196,6 @@ - [附录](appendix/intro.md) - [A-关键字](appendix/keywords.md) - [B-运算符与符号](appendix/operators.md) - - [C-派生特征derive](appendix/derive.md) - - [D-Rust版本发布](appendix/rust-version.md) - - [E-Rust自身开发流程](appendix/rust-dev.md) \ No newline at end of file + - [C-表达式](appendix/expressions.md) + - [D-派生特征derive](appendix/derive.md) + - [E-Rust版本发布](appendix/rust-version.md) \ No newline at end of file diff --git a/src/appendix/derive.md b/src/appendix/derive.md index 72d7a90c..ccb35d97 100644 --- a/src/appendix/derive.md +++ b/src/appendix/derive.md @@ -1,4 +1,4 @@ -## 附录 C：可派生的 trait +## 附录 D：可派生的 trait 在本书的各个部分中，我们讨论了可应用于结构体和枚举定义的 `derive` 属性。被`derive`标记的对象会自动实现对应的默认特征代码，继承相应的功能。 diff --git a/src/appendix/expressions.md b/src/appendix/expressions.md new file mode 100644 index 00000000..4202832a --- /dev/null +++ b/src/appendix/expressions.md @@ -0,0 +1,77 @@ +# C-表达式 + +在[语句与表达式]章节中，我们对表达式有过介绍，下面对这些常用表达式进行一一说明。 + +### 基本表达式 +```rust +let n = 3; +let s = "test"; +``` + +### if表达式 +```rust +fn main() { + let var1 = 10; + + let var2 = if var1 >= 10 { + var1 + } else { + var1 + 10 + }; + + println!("{}", var2); +} +``` + +通过`if`表达式将值赋予`var2`. + +你还可以在循环中结合`continue`、`break`来使用：` +```rust +let mut v = 0; +for i in 1..10 { + v = if i == 9 { continue } else { i } +} +println!("{}",v); +``` + +### if let表达式 +```rust +let o = Some(3); +let v = if let Some(x) = o { + x +} else { + 0 +}; +``` + +### match表达式 +```rust +let o = Some(3); +let v = match o { + Some(x) => x, + _ => 0 +}; +``` + +### loop表达式 +```rust +let mut n = 0; +let v = loop { + if n == 10 { + break n + } + n += 1; +}; +``` + +### 语句块{} +```rust +let mut n = 0; +let v = { + println!("before: {}", n); + n += 1; + println!("after: {}", n); + n +}; +println!("{}", v); +``` \ No newline at end of file diff --git a/src/appendix/rust-dev.md b/src/appendix/rust-dev.md deleted file mode 100644 index 092f1f82..00000000 --- a/src/appendix/rust-dev.md +++ /dev/null @@ -1,120 +0,0 @@ -## 附录E Rust自身开发流程 - - -本附录介绍 Rust语言自身是如何开发的以及这如何影响作为 Rust 开发者的你。 - -### 无停滞稳定 - -作为一个语言，Rust **十分** 注重代码的稳定性。我们希望 Rust 成为你代码坚实的基础，假如持续地有东西在变，这个希望就实现不了。但与此同时，如果不能实验新功能的话，在发布之前我们又无法发现其中重大的缺陷，而一旦发布便再也没有修改的机会了。 - -对于这个问题我们的解决方案被称为 “无停滞稳定”（“stability without stagnation”），其指导性原则是：无需担心升级到最新的稳定版 Rust。每次升级应该是无痛的，并应带来新功能，更少的 bug 和更快的编译速度。 - -### Choo, Choo! ~~ 小火车发布流程启动 - -开发Rust语言是基于一个**火车时刻表**来进行的：所有的开发工作在Master分支上完成，但是发布就像火车时刻表一样，拥有不同的时间，发布采用的软件发布列车模型，被用于思科IOS和等其它软件项目。Rust 有三个 **发布通道**（*release channel*）： - -* Nightly -* Beta -* Stable（稳定版） - -大部分 Rust 开发者主要采用稳定版通道，不过希望实验新功能的开发者可能会使用 nightly 或 beta 版。 - -如下是一个开发和发布过程如何运转的例子：假设 Rust 团队正在进行 Rust 1.5 的发布工作。该版本发布于 2015 年 12 月，这个版本和时间显然比较老了，不过这里只是为了提供一个真实的版本。Rust 新增了一项功能：一个 `master` 分支的新提交。每天晚上，会产生一个新的 nightly 版本。每天都是发布版本的日子，而这些发布由发布基础设施自动完成。所以随着时间推移，发布轨迹看起来像这样，版本一天一发： - -```text -nightly: * - - * - - * -``` - -每 6 周时间，是准备发布新版本的时候了！Rust 仓库的 `beta` 分支会从用于 nightly 的 `master` 分支产生。现在，有了两个发布版本： - -```text -nightly: * - - * - - * - | -beta: * -``` - -大部分 Rust 用户不会主要使用 beta 版本，不过在 CI 系统中对 beta 版本进行测试能够帮助 Rust 发现可能的回归缺陷（regression）。同时，每天仍产生 nightly 发布： - -```text -nightly: * - - * - - * - - * - - * - | -beta: * -``` - -比如我们发现了一个回归缺陷。好消息是在这些缺陷流入稳定发布之前还有一些时间来测试 beta 版本！fix 被合并到 `master`，为此 nightly 版本得到了修复，接着这些 fix 将 backport 到 `beta` 分支，一个新的 beta 发布就产生了： - -```text -nightly: * - - * - - * - - * - - * - - * - | -beta: * - - - - - - - - * -``` - -第一个 beta 版的 6 周后，是发布稳定版的时候了！`stable` 分支从 `beta` 分支生成： - -```text -nightly: * - - * - - * - - * - - * - - * - * - * - | -beta: * - - - - - - - - * - | -stable: * -``` - -好的！Rust 1.5 发布了！然而，我们忘了些东西：因为又过了 6 周，我们还需发布 **新版** Rust 的 beta 版，Rust 1.6。所以从 `beta` 生成 `stable` 分支后，新版的 `beta` 分支也再次从 `nightly` 生成： - -```text -nightly: * - - * - - * - - * - - * - - * - * - * - | | -beta: * - - - - - - - - * * - | -stable: * -``` - -这被称为 “train model”，因为每 6 周，一个版本 “离开车站”（“leaves the station”），不过从 beta 通道到达稳定通道还有一段旅程。 - -Rust 每 6 周发布一个版本，如时钟般准确。如果你知道了某个 Rust 版本的发布时间，就可以知道下个版本的时间：6 周后。每 6 周发布版本的一个好的方面是下一班车会来得更快。如果特定版本碰巧缺失某个功能也无需担心：另一个版本很快就会到来！这有助于减少因临近发版时间而偷偷释出未经完善的功能的压力。 - -多亏了这个过程，你总是可以切换到下一版本的 Rust 并验证是否可以轻易的升级：如果 beta 版不能如期工作，你可以向 Rust 团队报告并在发布稳定版之前得到修复！beta 版造成的破坏是非常少见的，不过 `rustc` 也不过是一个软件，可能会存在 bug。 - -### 不稳定功能 - -这个发布模型中另一个值得注意的地方：不稳定功能（unstable features）。Rust 使用一个被称为 “功能标记”（“feature flags”）的技术来确定给定版本的某个功能是否启用。如果新功能正在积极地开发中，其提交到了 `master`，因此会出现在 nightly 版中，不过会位于一个 **功能标记** 之后。作为用户，如果你希望尝试这个正在开发的功能，则可以在源码中使用合适的标记来开启，不过必须使用 nightly 版。 - -如果使用的是 beta 或稳定版 Rust，则不能使用任何功能标记。这是在新功能被宣布为永久稳定之前获得实用价值的关键。这既满足了希望使用最尖端技术的同学，那些坚持稳定版的同学也知道其代码不会被破坏。这就是无停滞稳定。 - -本书只包含稳定的功能，因为还在开发中的功能仍可能改变，当其进入稳定版时肯定会与编写本书的时候有所不同。你可以在网上获取 nightly 版的文档。 - -### Rustup 和 Rust Nightly 的职责 - -Rustup 使得改变不同发布通道的 Rust 更为简单，其在全局或分项目的层次工作。其默认会安装稳定版 Rust。例如为了安装 nightly： - -```text -$ rustup install nightly -``` - -你会发现 `rustup` 也安装了所有的 **工具链**（*toolchains*， Rust 和其相关组件）。如下是一位作者的 Windows 计算机上的例子： - -```powershell -> rustup toolchain list -stable-x86_64-pc-windows-msvc (default) -beta-x86_64-pc-windows-msvc -nightly-x86_64-pc-windows-msvc -``` - -如你所见，默认是稳定版。大部分 Rust 用户在大部分时间使用稳定版。你可能也会这么做，不过如果你关心最新的功能，可以为特定项目使用 nightly 版。为此，可以在项目目录使用 `rustup override` 来设置当前目录 `rustup` 使用 nightly 工具链： - -```text -$ cd ~/projects/needs-nightly -$ rustup override set nightly -``` - -现在，每次在 *~/需要nightly的项目/*下(在项目的根目录下，也就是Cargo.toml所在的目录) 调用 `rustc` 或 `cargo`，`rustup` 会确保使用 nightly 版 Rust。在你有很多 Rust 项目时大有裨益！ - -### RFC 过程和团队 - -那么你如何了解这些新功能呢？Rust 开发模式遵循一个 **Request For Comments (RFC) 过程**。如果你希望改进 Rust，可以编写一个提议，也就是 RFC。 - -任何人都可以编写 RFC 来改进 Rust，同时这些 RFC 会被 Rust 团队评审和讨论，他们由很多不同分工的子团队组成。这里是 [Rust 官网上](https://www.rust-lang.org/governance) 所有团队的总列表，其包含了项目中每个领域的团队：语言设计、编译器实现、基础设施、文档等。各个团队会阅读相应的提议和评论，编写回复，并最终达成接受或回绝功能的一致。 - -如果功能被接受了，在 Rust 仓库会打开一个 issue，人们就可以实现它。实现功能的人可能不是最初提议功能的人！当实现完成后，其会合并到 `master` 分支并位于一个特性开关（feature gate）之后，正如 [不稳定功能](#不稳定功能) 部分所讨论的。 - -在稍后的某个时间，一旦使用 nightly 版的 Rust 团队能够尝试这个功能了，团队成员会讨论这个功能在 nightly 中运行的情况，并决定是否应该进入稳定版。如果决定继续推进，特性开关会移除，然后这个功能就被认为是稳定的了！乘着“发布的列车”，最终在新的稳定版 Rust 中出现。 diff --git a/src/appendix/rust-version.md b/src/appendix/rust-version.md index 9f6a175b..4d926356 100644 --- a/src/appendix/rust-version.md +++ b/src/appendix/rust-version.md @@ -1,5 +1,6 @@ -## 附录 D：Rust版本 +# 附录 E：Rust版本发布 +## Rust版本说明 早在第一章，我们见过 `cargo new` 在 *Cargo.toml* 中增加了一些有关 `edition` 的元数据。本附录将解释其意义！ 与其它语言相比，Rust的更新迭代较为频繁(得益于精心设计过的发布流程以及Rust语言开发者团队管理)： @@ -23,3 +24,125 @@ 有一点需要明确：大部分功能在所有版本中都能使用。开发者使用任何 Rust 版本将能继续接收最新稳定版的改进。然而在一些情况，主要是增加了新关键字的时候，则可能出现了只能用于新版本的功能。只需切换版本即可利用新版本的功能。 请查看 [Edition Guide](https://rust-lang-nursery.github.io/edition-guide/) 了解更多细节，这是一个完全介绍版本的书籍，包括如何通过 `cargo fix` 自动将代码迁移到新版本。 + + +## Rust自身开发流程 + + +本附录介绍 Rust语言自身是如何开发的以及这如何影响作为 Rust 开发者的你。 + +### 无停滞稳定 + +作为一个语言，Rust **十分** 注重代码的稳定性。我们希望 Rust 成为你代码坚实的基础，假如持续地有东西在变，这个希望就实现不了。但与此同时，如果不能实验新功能的话，在发布之前我们又无法发现其中重大的缺陷，而一旦发布便再也没有修改的机会了。 + +对于这个问题我们的解决方案被称为 “无停滞稳定”（“stability without stagnation”），其指导性原则是：无需担心升级到最新的稳定版 Rust。每次升级应该是无痛的，并应带来新功能，更少的 bug 和更快的编译速度。 + +### Choo, Choo! ~~ 小火车发布流程启动 + +开发Rust语言是基于一个**火车时刻表**来进行的：所有的开发工作在Master分支上完成，但是发布就像火车时刻表一样，拥有不同的时间，发布采用的软件发布列车模型，被用于思科IOS和等其它软件项目。Rust 有三个 **发布通道**（*release channel*）： + +* Nightly +* Beta +* Stable（稳定版） + +大部分 Rust 开发者主要采用稳定版通道，不过希望实验新功能的开发者可能会使用 nightly 或 beta 版。 + +如下是一个开发和发布过程如何运转的例子：假设 Rust 团队正在进行 Rust 1.5 的发布工作。该版本发布于 2015 年 12 月，这个版本和时间显然比较老了，不过这里只是为了提供一个真实的版本。Rust 新增了一项功能：一个 `master` 分支的新提交。每天晚上，会产生一个新的 nightly 版本。每天都是发布版本的日子，而这些发布由发布基础设施自动完成。所以随着时间推移，发布轨迹看起来像这样，版本一天一发： + +```text +nightly: * - - * - - * +``` + +每 6 周时间，是准备发布新版本的时候了！Rust 仓库的 `beta` 分支会从用于 nightly 的 `master` 分支产生。现在，有了两个发布版本： + +```text +nightly: * - - * - - * + | +beta: * +``` + +大部分 Rust 用户不会主要使用 beta 版本，不过在 CI 系统中对 beta 版本进行测试能够帮助 Rust 发现可能的回归缺陷（regression）。同时，每天仍产生 nightly 发布： + +```text +nightly: * - - * - - * - - * - - * + | +beta: * +``` + +比如我们发现了一个回归缺陷。好消息是在这些缺陷流入稳定发布之前还有一些时间来测试 beta 版本！fix 被合并到 `master`，为此 nightly 版本得到了修复，接着这些 fix 将 backport 到 `beta` 分支，一个新的 beta 发布就产生了： + +```text +nightly: * - - * - - * - - * - - * - - * + | +beta: * - - - - - - - - * +``` + +第一个 beta 版的 6 周后，是发布稳定版的时候了！`stable` 分支从 `beta` 分支生成： + +```text +nightly: * - - * - - * - - * - - * - - * - * - * + | +beta: * - - - - - - - - * + | +stable: * +``` + +好的！Rust 1.5 发布了！然而，我们忘了些东西：因为又过了 6 周，我们还需发布 **新版** Rust 的 beta 版，Rust 1.6。所以从 `beta` 生成 `stable` 分支后，新版的 `beta` 分支也再次从 `nightly` 生成： + +```text +nightly: * - - * - - * - - * - - * - - * - * - * + | | +beta: * - - - - - - - - * * + | +stable: * +``` + +这被称为 “train model”，因为每 6 周，一个版本 “离开车站”（“leaves the station”），不过从 beta 通道到达稳定通道还有一段旅程。 + +Rust 每 6 周发布一个版本，如时钟般准确。如果你知道了某个 Rust 版本的发布时间，就可以知道下个版本的时间：6 周后。每 6 周发布版本的一个好的方面是下一班车会来得更快。如果特定版本碰巧缺失某个功能也无需担心：另一个版本很快就会到来！这有助于减少因临近发版时间而偷偷释出未经完善的功能的压力。 + +多亏了这个过程，你总是可以切换到下一版本的 Rust 并验证是否可以轻易的升级：如果 beta 版不能如期工作，你可以向 Rust 团队报告并在发布稳定版之前得到修复！beta 版造成的破坏是非常少见的，不过 `rustc` 也不过是一个软件，可能会存在 bug。 + +### 不稳定功能 + +这个发布模型中另一个值得注意的地方：不稳定功能（unstable features）。Rust 使用一个被称为 “功能标记”（“feature flags”）的技术来确定给定版本的某个功能是否启用。如果新功能正在积极地开发中，其提交到了 `master`，因此会出现在 nightly 版中，不过会位于一个 **功能标记** 之后。作为用户，如果你希望尝试这个正在开发的功能，则可以在源码中使用合适的标记来开启，不过必须使用 nightly 版。 + +如果使用的是 beta 或稳定版 Rust，则不能使用任何功能标记。这是在新功能被宣布为永久稳定之前获得实用价值的关键。这既满足了希望使用最尖端技术的同学，那些坚持稳定版的同学也知道其代码不会被破坏。这就是无停滞稳定。 + +本书只包含稳定的功能，因为还在开发中的功能仍可能改变，当其进入稳定版时肯定会与编写本书的时候有所不同。你可以在网上获取 nightly 版的文档。 + +### Rustup 和 Rust Nightly 的职责 + +Rustup 使得改变不同发布通道的 Rust 更为简单，其在全局或分项目的层次工作。其默认会安装稳定版 Rust。例如为了安装 nightly： + +```text +$ rustup install nightly +``` + +你会发现 `rustup` 也安装了所有的 **工具链**（*toolchains*， Rust 和其相关组件）。如下是一位作者的 Windows 计算机上的例子： + +```powershell +> rustup toolchain list +stable-x86_64-pc-windows-msvc (default) +beta-x86_64-pc-windows-msvc +nightly-x86_64-pc-windows-msvc +``` + +如你所见，默认是稳定版。大部分 Rust 用户在大部分时间使用稳定版。你可能也会这么做，不过如果你关心最新的功能，可以为特定项目使用 nightly 版。为此，可以在项目目录使用 `rustup override` 来设置当前目录 `rustup` 使用 nightly 工具链： + +```text +$ cd ~/projects/needs-nightly +$ rustup override set nightly +``` + +现在，每次在 *~/需要nightly的项目/*下(在项目的根目录下，也就是Cargo.toml所在的目录) 调用 `rustc` 或 `cargo`，`rustup` 会确保使用 nightly 版 Rust。在你有很多 Rust 项目时大有裨益！ + +### RFC 过程和团队 + +那么你如何了解这些新功能呢？Rust 开发模式遵循一个 **Request For Comments (RFC) 过程**。如果你希望改进 Rust，可以编写一个提议，也就是 RFC。 + +任何人都可以编写 RFC 来改进 Rust，同时这些 RFC 会被 Rust 团队评审和讨论，他们由很多不同分工的子团队组成。这里是 [Rust 官网上](https://www.rust-lang.org/governance) 所有团队的总列表，其包含了项目中每个领域的团队：语言设计、编译器实现、基础设施、文档等。各个团队会阅读相应的提议和评论，编写回复，并最终达成接受或回绝功能的一致。 + +如果功能被接受了，在 Rust 仓库会打开一个 issue，人们就可以实现它。实现功能的人可能不是最初提议功能的人！当实现完成后，其会合并到 `master` 分支并位于一个特性开关（feature gate）之后，正如 [不稳定功能](#不稳定功能) 部分所讨论的。 + +在稍后的某个时间，一旦使用 nightly 版的 Rust 团队能够尝试这个功能了，团队成员会讨论这个功能在 nightly 中运行的情况，并决定是否应该进入稳定版。如果决定继续推进，特性开关会移除，然后这个功能就被认为是稳定的了！乘着“发布的列车”，最终在新的稳定版 Rust 中出现。 diff --git a/src/basic/trait/advance-trait.md b/src/basic/trait/advance-trait.md index cf592858..62fbd777 100644 --- a/src/basic/trait/advance-trait.md +++ b/src/basic/trait/advance-trait.md @@ -1 +1,384 @@ # 进一步了解特征 + +特征之于Rust更甚于接口之于其他语言，因此特征在Rust中很重要也相对较为复杂，我们决定把特征分为两篇进行介绍，该篇就是关于特征的进阶篇，会讲述一些你不常用到但是该了解的特性。 + +## 关联类型 +在方法一章中，我们将到了[关联函数](../method.md#关联函数)，但是实际上关联类型和关联函数并没有任何交集，虽然它们的名字有一半的交集。 + +关联类型是在特征定义的语句块中，申明一个自定义类型，这样就可以在特征的方法签名中使用该类型： +```rust +pub trait Iterator { + type Item; + + fn next(&mut self) -> Option; +} +``` + +以上是标准库中的迭代器特征`Iterator`，它有一个`Item`关联类型，用于替代遍历的值的类型。 + +同时,`next`方法也返回了一个`Item`类型，不过使用`Option`枚举进行了包裹，假如迭代器中的值是`i32`类型，那么调用`next`方法就将获取一个`Option`的值。 + +还记得`Self`吧？在之前的章节[提到过](./trait-object#Self与self), `Self`用来指代当前的特征实例 ,那么`Self::Item`就用来指代特征实例中具体的`Item`类型: +```rust +impl Iterator for Counter { + type Item = u32; + + fn next(&mut self) -> Option { + // --snip-- +``` + +在上述代码中，我们为`Counter`类型实现了`Iterator`特征，那么`Self`就是当前的`Iterator`特征对象，`Item`就是`u32`类型。 + +聪明的读者之所以聪明，因为你们喜欢联想和举一反三，同时你们也喜欢提问：为何不用泛型，例如如下代码 +```rust +pub trait Iterator { + fn next(&mut self) -> Option; +} +``` + +答案其实很简单，为了代码的可读性. 当你使用了泛型后，你需要在所有地方都这样写`Iterator`，而使用了关联类型，你只需要这样写`Iterator`，当类型定义复杂时，这种写法可以极大的增加可读性: +```rust +pub trait CacheableItem: Clone + Default + fmt::Debug + Decodable + Encodable { + type Address: AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash; + fn is_null(&self) -> bool; +} +``` + +例如上面的代码，`Address`自然远比`AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash`的要简单的多，而且含义清晰。 + +再例如，如果使用泛型，你将得到以下的代码： +```rust +trait Container { + fn contains(&self,a: A,b: B) -> bool; +} + +fn difference(container: &C) -> i32 where + C : Container {...} +``` + +而使用关联类型，将得到可读性好的多的代码: +```rust +trait Container{ + type A; + type B; + fn contains(&self, a: &Self::A, b: &Self::B) -> bool; +} + +fn difference(container: &C) {} +``` + +## 默认泛型类型参数 + +当使用泛型类型参数时，可以为其指定一个默认的具体类型，例如标准库中的`std::ops::Add`特征： +```rust +trait Add { + type Output; + + fn add(self, rhs: RHS) -> Self::Output; +} +``` +它有一个泛型参数`RHS`，但是与我们以往的用法不同，这里它给`RHS`一个默认值，也就是当用户不指定`RHS`时，默认使用两个同样类型的值进行相加，然后返回一个关联类型`Outpu`。 + +可能上面那段不太好理解，下面我们用代码来举例： +```rust +use std::ops::Add; + +#[derive(Debug, PartialEq)] +struct Point { + x: i32, + y: i32, +} + +impl Add for Point { + type Output = Point; + + fn add(self, other: Point) -> Point { + Point { + x: self.x + other.x, + y: self.y + other.y, + } + } +} + +fn main() { + assert_eq!(Point { x: 1, y: 0 } + Point { x: 2, y: 3 }, + Point { x: 3, y: 3 }); +} +``` +上面的代码主要干了一件事，就是为`Point`结构体提供`+`的能力，这就是**运算符重载**，不过Rust并不支持创建自定义运算符，你也无法为所有运算符进行重载，目前来说，只有定义在`std::ops`中的运算符才能进行重载。 + +跟`+`对应的特征是`std::ops::Add`，我们在之前也看过它的定义`trait Add`，但是上面的例子中并没有为`Point`实现`Add`特征，而是实现了`Add`特征，这意味着我们使用了`RHS`的默认类型，也就是`Self`。换句话说，我们这里定义的是两个相同的`Point`类型相加，因此无需指定`RHS`。 + +与上面的例子相反，下面的例子，我们来创建两个不同类型的相加： +```rust +use std::ops::Add; + +struct Millimeters(u32); +struct Meters(u32); + +impl Add for Millimeters { + type Output = Millimeters; + + fn add(self, other: Meters) -> Millimeters { + Millimeters(self.0 + (other.0 * 1000)) + } +} +``` + +这里，是进行`Millimeters + Meters`的操作，因此此时不能再使用默认的RHS，否则就会变成`Millimeters + Millimeters`的形式。使用`Add`可以将`RHS`指定为`Meters`，那么`fn add(self, rhs: RHS) `自然而言的变成了`Millimeters`和`Meters`的相加. + +默认类型参数主要用于两个方面： +1. 减少实现的样板代码 +2. 扩展类型但是无需大幅修改现有的代码 + +之前的例子就是第一点，虽然效果也就那样。在`+`左右两边都是同样类型时，只需要`impl Add`即可，否则你需要`impl Add`，嗯，会多写几个字:) + +对于第二点，也很好理解，如果你在一个复杂类型的基础上，新引入一个泛型参数，可能需要修改很多地方，但是如果新引入的泛型参数有了默认类型，情况就会好很多。 + +归根到底，默认泛型参数，是有用的，但是大多数情况下，咱们确实用不到，当需要用到时，大家再回头来查阅本章即可, **手上有剑,心中不慌**. + +## 调用同名的方法 +不同特征拥有同名的方法是很正常的事情，你没有任何办法阻止这一点，甚至除了特征上的同名方法外，在你的类型上，也有同名方法: +```rust +trait Pilot { + fn fly(&self); +} + +trait Wizard { + fn fly(&self); +} + +struct Human; + +impl Pilot for Human { + fn fly(&self) { + println!("This is your captain speaking."); + } +} + +impl Wizard for Human { + fn fly(&self) { + println!("Up!"); + } +} + +impl Human { + fn fly(&self) { + println!("*waving arms furiously*"); + } +} +``` + +这里，不仅仅两个特征`Pilot`和`Wizard`有`fly`方法，就连实现那两个特征的`Human`元结构体，也拥有一个同名方法`fly`(这世界怎么了，非常这么卷吗？程序员何苦难为程序员,哎). + +既然代码已经不可更改，那下面我们来讲讲该如何调用这些`fly`方法。 + +#### 优先调用类型上的方法 +当调用`Human`实例的`fly`时，编译器默认调用该类型中定义的方法: +```rust +fn main() { + let person = Human; + person.fly(); +} +``` +这段代码会打印`*waving arms furiously*`，说明直接调用了类型上定义的方法。 + +#### 调用特征上的方法 +为了能够调用两个特征的方法，需要使用显式调用的语法： +```rust +fn main() { + let person = Human; + Pilot::fly(&person); // 调用Pilot特征上的方法 + Wizard::fly(&person); // 调用Wizard特征上的方法 + person.fly(); // 调用Human类型自身的方法 +} +``` + +运行后依次输出: +```console +fn main() { + let person = Human; + Pilot::fly(&person); + Wizard::fly(&person); + person.fly(); +} +``` + +因为`fly`方法的参数是`self`，当显示的调用时，编译器就可以根据调用的类型(`self`的类型)决定具体调用哪个方法。 + +这个时候问题又来了，如果方法没有`self`参数呢？稍等，估计有读者会问：还有方法没有`self`参数？看到这个疑问，作者的眼泪不禁流了下来, 大明湖畔的[关联函数](../method.md#关联函数)，你还记得嘛？ + +但是成年人的世界，就算再伤心，事还得做，咱们继续： +```rust +trait Animal { + fn baby_name() -> String; +} + +struct Dog; + +impl Dog { + fn baby_name() -> String { + String::from("Spot") + } +} + +impl Animal for Dog { + fn baby_name() -> String { + String::from("puppy") + } +} + +fn main() { + println!("A baby dog is called a {}", Dog::baby_name()); +} +``` + +就像人类妈妈会给自己的宝宝起爱称一样，狗狗妈妈也会。狗狗妈称呼自己的宝宝为**Spot**，其它动物称呼狗宝宝为**puppy**, 这个时候假如有其它动物，不知道该称如何呼狗宝宝，它需要查询一下。 + +但是`Dog::baby_name()`的调用方式显然不行，这是狗妈妈对宝宝的爱称，但是如果你试图这样查询： +```rust +fn main() { + println!("A baby dog is called a {}", Animal::baby_name()); +} +``` + +铛铛，无情报错了: +```rust +error[E0283]: type annotations needed // 需要类型注释 + --> src/main.rs:20:43 + | +20 | println!("A baby dog is called a {}", Animal::baby_name()); + | ^^^^^^^^^^^^^^^^^ cannot infer type // 无法推断类型 + | + = note: cannot satisfy `_: Animal` +``` + +因为单纯从`Animal::baby_name()`上，编译器无法得到任何有效的信息：你想获取哪个动物宝宝的名称？狗宝宝？猪宝宝？还是熊宝宝？ + +此时，就需要使用**完全限定语法**. + +##### 完全限定语法 +完全限定语法是调用函数最为明确的方式: +```rust +fn main() { + println!("A baby dog is called a {}", ::baby_name()); +} +``` +在尖括号中，通过`as`关键字，我们向Rust编译器提供了类型注解，也就是`Animal`就是`Dog`，而不是其他动物，因此最终会调用`impl Animal for Dog `中的方法，获取到其它动物对狗宝宝的称呼：**puppy**. + +言归正题，完全限定语法定义为: +```rust +::function(receiver_if_method, next_arg, ...); +``` + +对于关联函数，其没有一个方法接收器(`receiver`)，故只会有其他参数的列表。**可以选择在任何函数或方法调用处使用完全限定语法**, 同时，你还能省略任何Rust能够从程序中的其他信息中推导出的的部分。只有当存在多个同名实现而 Rust 需要帮助以便知道我们希望调用哪个实现时，才需要使用这个较为冗长的语法。 + + +## 特征定义中的特征约束 +有时，我们会需要让某个特征A能使用另一个特征B的功能(另一种形式的特征约束)，这种情况下，不仅仅要为类型实现特征A，还要为类型实现特征B才行，这就是`supertrait`(实在不知道该如何翻译，有大佬指导下嘛？) + +例如有一个特征`OutlinePrint`，它有一个方法，能够对当前的实现类型进行格式化输出： +```rust +use std::fmt::Display; + +trait OutlinePrint: Display { + fn outline_print(&self) { + let output = self.to_string(); + let len = output.len(); + println!("{}", "*".repeat(len + 4)); + println!("*{}*", " ".repeat(len + 2)); + println!("* {} *", output); + println!("*{}*", " ".repeat(len + 2)); + println!("{}", "*".repeat(len + 4)); + } +} +``` + +等等，这里有一个眼熟的语法:`OutlinePrint: Display`，感觉很像之前讲过的**特征约束**，只不过用在了特征定义中而不是函数的参数中, 是的，在某种意义上来说，这和特征约束非常类似，都用来说明一个特征需要实现另一个特征，这里就是：如果你想要实现`OutlinePrint`特征，首先你需要实现`Display`特征。 + +想象一下，假如没有这个特征约束，那么`self.to_string`还能够调用吗(`to_string`方法会为实现`Display`特征的类型自动实现)？编译器肯定是不愿意的, 会报错说当前作用域中找不到用于`&Self`类型的方法`to_string`: +```rust +struct Point { + x: i32, + y: i32, +} + +impl OutlinePrint for Point {} +``` +因为`Point`没有实现`Display`特征，会得到下面的报错： +```console +error[E0277]: the trait bound `Point: std::fmt::Display` is not satisfied + --> src/main.rs:20:6 + | +20 | impl OutlinePrint for Point {} + | ^^^^^^^^^^^^ `Point` cannot be formatted with the default formatter; +try using `:?` instead if you are using a format string + | + = help: the trait `std::fmt::Display` is not implemented for `Point` +``` + +既然我们有求于编译器，那只能选择满足它咯： +```rust +use std::fmt; + +impl fmt::Display for Point { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "({}, {})", self.x, self.y) + } +} +``` + +上面代码为`Point`实现了`Display`特征，那么`to_string`方法也将自动实现：最终获得字符串是通过这里的`fmt`方法获得的。 + +## 在外部类型上实现外部特征(newtype) + + 在[特征](./trait#特征定义与实现的位置(孤儿规则))章节中, 有提到孤儿规则，简单来说，就是特征或者类型必需至少有一个是本地的，才能在此类型上定义特征。 + + 这里提供一个办法来绕过孤儿规则, 那就是使用**newtype模式**，简而言之: 就是为一个[元组结构体](../compound-type/struct.md#元组结构体)创建新类型。该元组结构体封装有一个字段，该字段就是希望实现特征的具体类型。 + + 该封装类型是本地的，因此我们可以为此类型实现外部的特征。 + + `newtype`不仅仅能实现以上的功能，而且它在运行时没有任何性能损耗，因为在编译期，该类型会被自动忽略。 + + 下面来看一个例子，我们有一个动态数组类型：`Vec`，它定义在标准库中，还有一个特征`Display`，它也定义在标准库中，如果没有`newtype`，我们是无法为`Vec`实现`Display`的: + ```rust + error[E0117]: only traits defined in the current crate can be implemented for arbitrary types + --> src/main.rs:5:1 + | +5 | impl std::fmt::Display for Vec { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^------ + | | | + | | `Vec` is not defined in the current crate + | impl doesn't use only types from inside the current crate + | + = note: define and implement a trait or new type instead +``` + +编译器给了我们提示：`define and implement a trait or new type instead`，重新定义一个特征，或者使用`new type`，前者当然不可行，那么来试试后者： +```rust +use std::fmt; + +struct Wrapper(Vec); + +impl fmt::Display for Wrapper { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "[{}]", self.0.join(", ")) + } +} + +fn main() { + let w = Wrapper(vec![String::from("hello"), String::from("world")]); + println!("w = {}", w); +} +``` + +其中，`struct Wrapper(Vec)`就是一个元组结构体，它定义了一个新类型`Wrapper`，代码很简单，相信大家也很容易看懂。 + +既然`new type`有这么多好处，它有没有不好的地方呢？答案是肯定的。注意到我们怎么访问里面的数组吗？`self.0.join(", ")`, 是的，很啰嗦，因为需要先从`Wrapper`中取出数组: `self.0`，然后才能执行`join`方法. + +类似的，任何数组上的方法，你都无法直接调用，需要先用`self.0`取出数组，然后再进行调用。 + +当然，解决办法还是有的，要不怎么说Rust是极其强大灵活的编程语言！Rust提供了一个特征叫[`Deref`](../../traits/deref.md)，实现该特征后，可以自动做一层类似类型转换的操作，可以将`Wrapper`变成`Vec`来使用。这样就会像直接使用数组那样去使用`Wrapper`，而无需为每一个操作都添加上`self.0`。 + +同时，如果不想`Wrapper`暴漏底层数组的所有方法，我们还可以为`Wrapper`去重载这些方法，实现隐藏的目的。 + diff --git a/src/basic/trait/trait.md b/src/basic/trait/trait.md index d3714109..27ed826b 100644 --- a/src/basic/trait/trait.md +++ b/src/basic/trait/trait.md @@ -82,7 +82,7 @@ sunface发表了微博好像微博没Tweet好用 说实话，如果特征仅仅如此，你可能会觉得花里胡哨没啥子用，等下就让你见识下真正的威力。 -#### 特征定义与实现的位置 +#### 特征定义与实现的位置(孤儿规则) 上面我们将`Summary`定义为了`pub`公开的，因此如果他人想要使用我们的`Summary`特征，则可以引入到他们的包中，然后再进行实现。 关于特征实现与定义的位置，有一条非常重要的原则: **如果你想要为类型`A`实现特征`T`，那么`A`或者`T`至少有一个是在当前作用域中定义的！**.例如我们可以为上面的`Post`类型实现标准库中的`Display`特征，这是因为`Post`类型定义在当前的作用域中。同时，我们也可以在当前包中为`String`类型实现`Summary`特征，因为`Summary`定义在当前作用域中。 @@ -394,9 +394,11 @@ fn main() { 详细的`derive`列表参加[附录-派生特征](../../appendix/derive.md). -## 一个复杂的例子 +## 几个综合例子 + +#### 为自定义类型实现`+`操作 +在Rust中除了数值类型的加法，`String`也可以做[加法](../compound-type/string-slice.md#操作字符串)，因为Rust为该类型实现了`std::ops::Add`特征，同理，如果我们为自定义类型实现了该特征，那就可以实现`Point1 + Point2`的操作: -综合上面的内容，我们再来看一个复杂一些的例子： ```rust use std::ops::Add; @@ -433,7 +435,75 @@ fn main() { } ``` -在上面代码中，除了泛型之外，最值得注意的是我们实现了两个结构体的加法，具体细节留给读者细细琢磨，若有问题可以加入交流群讨论。 +#### 自定义类型的打印输出 +在开发过程中，往往只要使用`#[derive(Debug)]`对我们的自定义类型进行标注，即可实现打印输出的功能： +```rust +#[derive(Debug)] +struct Point{ + x: i32, + y: i32 +} +fn main() { + let p = Point{x:3,y:3}; + println!("{:?}",p); +} +``` +但是在实际项目中，往往需要对我们的自定义类型进行自定义的格式化输出，以让用户更好的阅读理解我们的类型，此时就要为自定义类型实现`std::fmt::Display`特征： +```rust +#![allow(dead_code)] + +use std::fmt; +use std::fmt::{Display}; + +#[derive(Debug,PartialEq)] +enum FileState { + Open, + Closed, +} + +#[derive(Debug)] +struct File { + name: String, + data: Vec, + state: FileState, +} + +impl Display for FileState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match *self { + FileState::Open => write!(f, "OPEN"), + FileState::Closed => write!(f, "CLOSED"), + } + } +} + +impl Display for File { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "<{} ({})>", + self.name, self.state) + } +} + +impl File { + fn new(name: &str) -> File { + File { + name: String::from(name), + data: Vec::new(), + state: FileState::Closed, + } + } +} + +fn main() { + let f6 = File::new("f6.txt"); + //... + println!("{:?}", f6); + println!("{}", f6); +} +``` + + +以上两个例子较为复杂，目的是为读者展示下真实的使用场景长什么样，因此需要读者细细阅读，最终消化这些知识对于你的Rust之路会有莫大的帮助。 -特征和特征约束，是Rust中极其重要的概念，如果你还是没搞懂，强烈建议回头再看一遍，或者寻找相关的资料进行补充学习。如果已经觉得掌握了，那么就进入下一节的学习。 \ No newline at end of file +最后，特征和特征约束，是Rust中极其重要的概念，如果你还是没搞懂，强烈建议回头再看一遍，或者寻找相关的资料进行补充学习。如果已经觉得掌握了，那么就进入下一节的学习。 \ No newline at end of file diff --git a/src/performance/early-optimise.md b/src/performance/early-optimise.md new file mode 100644 index 00000000..473a01d0 --- /dev/null +++ b/src/performance/early-optimise.md @@ -0,0 +1,7 @@ +# 糟糕的提前优化 + + +## 函数调用 +由于Rust的编译器和LLVM很强大，因此就算你使用了多层函数调用去完成一件事(嵌套函数调用往往出于设计上的考虑)，依然不会有性能上的影响，因为最终生成的机器码会消除这些多余的函数调用。 + +总之用Rust时，你不必操心多余的函数调用，只要写合理的代码，然后Rust会帮助你运行的更快! \ No newline at end of file