mod_trait_exerci = "0.2.1"

Author: cnruby

docs/zh-first-volumn/src/SUMMARY.md

@@ -22,9 +22,10 @@
   - [使用软件篋borrowing_exerci](./hello-borrowing/apply.md)
 - [软件篋trait_exerci](./hello-trait/README.md)
   - [类型关键词`struct`](./hello-trait/examples-struct.md)
-  - [实现关键词`impl`与方法代码实现](./hello-trait/examples-impl.md)
-  - [方法代码实现](./hello-trait/examples-methods.md) 
-  - [衔接关键词trait与修饰关键词mut](./hello-trait/examples-trait.md)
+  - [关键词`impl`与方法代码实现](./hello-trait/examples-impl.md)
+  - [函数与方法代码实现](./hello-trait/examples-methods.md) 
+  - [衔接关键词trait](./hello-trait/examples-trait.md)
+  - [特质实现及其对象](./hello-trait/examples-trait-impl.md)
   - [题外话：默认衔接特质Default](./hello-trait/examples-trait-default.md)
   - [程序代码结构](./hello-trait/lib-structure.md)
   - [关于软件篋项目](./hello-trait/about.md)
@@ -42,7 +43,7 @@
   - [共享篋：简单三层结构实现](./hello-mod-trait/lib-fn.md)
   - [共享篋：基于封装的静态调度实现](./hello-mod-trait/lib-static.md)
   - [共享篋：基于封装的动态调度实现](./hello-mod-trait/lib-dynamic.md)
-  - [共享篋：目录测试代码解释](./hello-mod-trait/lib-tests.md)
+  - [共享篋：单元测试代码解释](./hello-mod-trait/lib-tests.md)
   - [题外话：泛型实例](./hello-mod-trait/off-topic.md)
 - [软件篋deref_exerci](./hello-deref/README.md)
   - [关于软件篋deref_exerci](./hello-deref/about.md)

docs/zh-first-volumn/src/hello-mod-trait/examples-miri.md

@@ -12,6 +12,7 @@
 - [与Miri相关的Cargo工具命令](#与Miri相关的Cargo工具命令)
 - [打开Miri代码文件命令](#打开Miri代码文件命令)
 - [Miri代码实例说明](#Miri代码实例说明)
+- [类型泛型参数与特质对象](#类型泛型参数与特质对象)
 - [参考资料](#参考资料)
 
 ## 什么是Miri
@@ -87,5 +88,9 @@ fn  dynamic_dispatch(_1: &dyn Trait) -> () {
 }
 ```
 
+## 类型泛型参数与特质对象
+
+　　类型泛型参数（generics type parameters）与特质对象（trait objects）
+
 ## 参考资料
 - [An interpreter for Rust's mid-level intermediate representation](https://github.com/rust-lang/miri)

docs/zh-first-volumn/src/hello-mod-trait/lib-dynamic.md

@@ -1,7 +1,22 @@
 # 共享篋：基于封装的动态调度实现
 
+　　在这一节里，列出基于指针类型`Box`封装的动态调度实现。
 
+## 学习内容
+- 了解和学习基于指针类型`Box`封装的动态函数实现方法
+
+## 篇目
+- [动态模块实现](#动态模块实现)
+- [动态模块应用](#动态模块应用)
+- [参考资料](#参考资料)
+
+## 动态模块实现
 
 {{#playpen ../../../../hello-mod-trait/lib-hello/src/mod_box_dynamic_fn.rs editable}}
 
-{{#playpen ../../../../hello-mod-trait/lib-hello/examples/box_dynamic_hello.rs editable}}
+## 动态模块应用
+
+{{#playpen ../../../../hello-mod-trait/lib-hello/examples/box_dynamic_hello.rs editable}}
+
+## 参考资料
+- 

docs/zh-first-volumn/src/hello-mod-trait/lib-fn.md

@@ -40,7 +40,4 @@
 
 {{#playpen ../../../../hello-mod-trait/lib-hello/examples/trait_fn_hello.rs editable}}
 
-
-
-
 ## 参考资料

docs/zh-first-volumn/src/hello-mod-trait/lib-static.md

@@ -1,23 +1,25 @@
 # 共享篋：基于封装的静态调度实现
 
-　　在这一节里，学习Cargo项目文件、目录与模块相互关系。Rust语言表达模块的三种方式。
+　　在这一节里，列出基于指针类型`Box`封装的静态调度实现。
 
 ## 学习内容
-- 了解和学习本软件篋模块文件结构
-- 理解和掌握Cargo项目目录与文件关系
-- 理解和掌握Cargo项目模块与文件关系
-- 理解和掌握Cargo项目文件与文件关系
+- 了解和学习基于指针类型`Box`封装的静态函数实现方法
 
 ## 篇目
-- [文件本身表达模块方式](#文件本身表达模块方式)
-- [文件名称表达模块方式](#文件名称表达模块方式)
-- [目录名称表达模块方式](#目录名称表达模块方式)
+- [静态模块实现](#静态模块实现)
+- [静态模块应用](#静态模块应用)
 - [参考资料](#参考资料)
 
+## 静态模块实现
 
-
+　　
 
 {{#playpen ../../../../hello-mod-trait/lib-hello/src/mod_box_static_fn.rs editable}}
 
+## 静态模块应用
+
+{{#playpen ../../../../hello-mod-trait/lib-hello/examples/box_static_hello.rs editable}}
+
 
-{{#playpen ../../../../hello-mod-trait/lib-hello/examples/box_static_hello.rs editable}}
+## 参考资料
+- [std Box](https://doc.rust-lang.org/std/boxed/struct.Box.html)

docs/zh-first-volumn/src/hello-mod-trait/lib-tests.md

@@ -1 +1,37 @@
-# 共享篋：目录tests的测试代码解释
+# 共享篋：单元测试代码解释
+
+　　在这一节里，实现共享篋每一个模块的单元测试代码。
+
+## 学习内容
+- 了解和学习实现基于不同类型的单元测试方法
+
+## 篇目
+- [模块`mod_bare`单元测试](#模块mod_bare单元测试)
+- [基于实例的模块`mod_trait`单元测试](#基于实例的模块mod_trait单元测试)
+- [基于中间模块的实例单元测试](#基于中间模块的实例单元测试)
+- [基于中间模块静态函数的类型`Box`单元测试](#基于中间模块静态函数的类型Box单元测试)
+- [基于中间模块动态函数的类型`Box`单元测试](#基于中间模块动态函数的类型Box单元测试)
+- [参考资料](#参考资料)
+
+## 模块`mod_bare`单元测试
+
+{{#playpen ../../../../hello-mod-trait/lib-hello/tests/u_for_mod_bare.rs editable}}
+
+## 基于实例的模块`mod_trait`单元测试
+
+{{#playpen ../../../../hello-mod-trait/lib-hello/tests/u_for_mod_trait_instance.rs editable}}
+
+## 基于中间模块的实例单元测试
+
+{{#playpen ../../../../hello-mod-trait/lib-hello/tests/u_for_mod_trait_fn.rs editable}}
+
+## 基于中间模块静态函数的类型`Box`单元测试
+
+{{#playpen ../../../../hello-mod-trait/lib-hello/tests/u_for_box_static_hello.rs editable}}
+
+## 基于中间模块动态函数的类型`Box`单元测试
+
+{{#playpen ../../../../hello-mod-trait/lib-hello/tests/u_for_box_dynamic_hello.rs editable}}
+
+## 参考资料
+- 

docs/zh-first-volumn/src/hello-trait/README.md

@@ -1,42 +1,17 @@
 # 第二章 软件篋trait_exerci
 
-### 学习内容
+### 本章学习内容
 - 什么是Rust语言衔接关键词trait
 - 为什么需要衔接关键词trait
 - 怎么样实现Rust语言衔接关键词trait
 - 实现关键词impl与衔接关键词trait是什么关系
 
-### 篇目
+### 本节篇目
 
-1. [关键词trait概念表述之一](#关键词trait概念表述之一)
-1. [关键词trait概念表述之二](#关键词trait概念表述之二)
-1. [关键词trait概念表述之三](#关键词trait概念表述之三)
-1. [解释关键词trait](#解释关键词trait)
-1. [题外话](#题外话)
-   1. [怎么样使用Rust语言nightly版本](#怎么样使用rust语言nightly版本)
-   1. [参考资料](#参考资料)
-1. [本章参考资料](#本章参考资料)
-
-## 关键词trait概念表述之一
-
-　　[关键词trait][id_01]是Rust语言的一项功能，可以告诉Rust编译器一种类型必须提供的功能。
-
-## 关键词trait概念表述之二
-
-　　[关键词trait][id_02]是为任何未知类型定义方法的集合。
-
-## 关键词trait概念表述之三
-
-　　[关键词trait][id_03]告诉Rust编译器一种特定的类型具有且可与其他类型共享的功效性质。
-
-## 解释关键词trait
-
-　　关键词trait提供了一种类型或者几种类型之间的衔接方式。它应该包含下面内容：
-
-- 存在一种类型或者几种类型
-- 使用关键词trait定义衔接名称
-- 使用关键词trait代码块定义方法和函数
-- 使用关键词"impl"和"for"组合，实现针对这一种类型或者这几种类型的方法和函数
+- [题外话](#题外话)
+   - [怎么样使用Rust语言nightly版本](#怎么样使用rust语言nightly版本)
+   - [参考资料](#参考资料)
+- [本章参考资料](#本章参考资料)
 
 ## 题外话
 

docs/zh-first-volumn/src/hello-trait/examples-impl.md

@@ -1,4 +1,4 @@
-# 实现关键词`impl`与方法代码实现
+# 关键词`impl`与方法代码实现
 
 ## 学习内容
 - 阐述关键词`impl`基本概念

docs/zh-first-volumn/src/hello-trait/examples-methods.md

@@ -1,18 +1,18 @@
-# 方法代码实现
+# 函数与方法代码实现
 
 ## 学习内容
 - 阐述Rust语言函数与方法概念区别
 - 理解实现函数与方法手段
 
 ## 篇目
 
-1. [修饰实例关键词`mut`概念](#修饰实例关键词mut概念)
-1. [函数与方法概念](#函数与方法概念)
-1. [实现方法代码](#实现方法代码)
-1. [结构类型属性的私有性](#结构类型属性的私有性)
-1. [题外话](#题外话)
-1. [在终端里怎么样使用表格形式](#在终端里怎么样使用表格形式)
-1. [参考资料](#参考资料)
+- [修饰实例关键词`mut`概念](#修饰实例关键词mut概念)
+- [函数与方法概念](#函数与方法概念)
+- [实现方法代码](#实现方法代码)
+- [结构类型属性的私有性](#结构类型属性的私有性)
+- [题外话](#题外话)
+- [在终端里怎么样使用表格形式](#在终端里怎么样使用表格形式)
+- [参考资料](#参考资料)
 
 ## 修饰实例关键词`mut`概念
 

docs/zh-first-volumn/src/hello-trait/examples-trait-impl.md

@@ -0,0 +1,73 @@
+# 特质实现及其对象
+
+## 学习内容
+- 理解衔接类型关键词`trait`的实现
+
+## 篇目
+
+- [程序结构图与衔接类型关键词`trait`](#程序结构图与衔接类型关键词trait)
+- [实现基于默认方法的关键词`trait`代码](#实现基于默认方法的关键词trait代码)
+- [特质对象解释](#特质对象解释)
+- [题外话](#题外话)
+- [什么是可衍生特质](#什么是可衍生特质)
+- [参考资料](#参考资料)
+
+## 程序结构图与衔接类型关键词trait
+
+![image](../../images/hello-trait-03-trait-impl.png)
+
+## 实现基于默认方法的关键词trait代码
+
+　　通过下面的代码，可以学习到这些知识：
+
+- 使用关键词`trait`，定义了特质`TraitCanal`的默认实例化函数`init()`；
+- 使用关键词`impl`和`for`，基于结构类型`StructType`，为特质`TraitCanal`实现了方法`new()`、get_data()`和`set_data()`；
+- 借助于特质`TraitCanal`的默认实例化函数`init()`，实现该结构类型的实例化方式；
+
+{{#playpen ../../../../hello-trait/lib-hello/examples/trait_with_default_method.rs editable}}
+
+## 特质对象解释
+
+　　特质本身不能定义特质对象，而是通过类型的对象，进行强制转换得到的特质对象。特质对象可以访问类型的公共数据和公共特质的行为。
+
+　　Rust语言把面向对象编程的思想更加深化了。把类的数据与行为分散化定义，而把类的实例集成化使用。不仅如此，而且Rust语言在代码里完全把这种过程都隐藏起来了。
+
+![image](../../images/hello-trait-31-trait-object.png)
+
+## 题外话
+
+### 什么是可衍生特质
+
+　　Rust语言标准库或者第三方提供了一些非常有用的特质，称之为可衍生特质（Derivable Trait）。通过注释`#[derive(特质名称)]`，编译器能够为这些特质提供实现。比如，要求类型实现是可打印的，可以使用特质std::fmt::Debug。具体说，使用可衍生特质#[derive(Debug)]，所有类型都可以自动创建地实现std::fmt::Debug。
+
+　　下面的代码里第一行就是注释可衍生特质`Debug`，为类型`Person`实现了特质`Debug`，这些后面的宏`println!()`就可以使用了这个特质。
+
+　　注意，使用注释`#[derive(特质名称)]`，必须紧挨着类型定义之上。
+
+```rust
+#[derive(Debug)]
+struct Person {
+  name: String,
+  age: u32,
+}
+
+impl Person {
+    fn init() -> Person {
+        Person {
+            name: String::new(),
+            age: 0,
+        }
+    }
+}
+
+fn main() {
+    let person = Person::init();
+    println!("{:?}", person);
+}
+```
+
+## 参考资料
+- [trait std::fmt::Debug](https://doc.rust-lang.org/std/fmt/trait.Debug.html)
+- [rust-by-example derive](https://doc.rust-lang.org/rust-by-example/trait/derive.html)
+- [rust-by-example print_debug](https://doc.rust-lang.org/rust-by-example/hello/print/print_debug.html)
+- [appendix-03-derivable-traits](https://doc.rust-lang.org/book/appendix-03-derivable-traits.html#appendix-c-derivable-traits)