YuKnight
diff --git a/‎book/9-cpp17.md‎ ‎book/10-cpp20.md‎book/9-cpp17.md renamed to book/10-cpp20.md
Lines changed: 6 additions & 7 deletions b/‎book/9-cpp17.md‎ ‎book/10-cpp20.md‎book/9-cpp17.md renamed to book/10-cpp20.md
Lines changed: 6 additions & 7 deletions
diff --git a/‎book/2-usability.md‎
Lines changed: 52 additions & 52 deletions b/‎book/2-usability.md‎
Lines changed: 52 additions & 52 deletions
@@ -1,21 +1,20 @@
-# 第九章 扩展主题：C++17 简介
+# 第九章 展望: C++20 简介
 
-> 内容修订中
+> 内容修订中, 目前内容为第一版中对 C++17 的展望
 
 ## 一、本节内容
 
 本节内容包括：
 
 - 扩展主题: C++17 简介
 + 主要入选特性
-+ 非类型模板参数的 `auto`
-+ `std::variant<>`
-+ 结构化绑定(Structured bindings)
+    + 非类型模板参数的 `auto`
+    + `std::variant<>`
 + 变量声明的强化
 + 未入选特性
-+ Concepts
+    + Concepts
 
-本节对即将到来的 C++17 进行介绍，几个月前（2016 年），目前为止，还没有一个正式发布的编译器来编译 C++17 特性的代码，本节作为扩展主题，供对 C++ 的历史进程及其未来发展感兴趣的读者阅读。
+本章对即将到来的 C++17 进行介绍，几个月前（2016 年），目前为止，还没有一个正式发布的编译器来编译 C++17 特性的代码，本节作为扩展主题，供对 C++ 的历史进程及其未来发展感兴趣的读者阅读。
 
 ## 二、主要入选特性
 
 
@@ -559,14 +559,14 @@ extern template class std::vector<MagicClass>; // 不在该编译文件中实例
 在传统 C++ 的编译器中，`>>`一律被当做右移运算符来进行处理。但实际上我们很容易就写出了嵌套模板的代码：
 
 ```cpp
-std::vector<std::vector<int>> mtx;
+    std::vector<std::vector<int>> mtx;
 ```
 
 这在传统C++编译器下是不能够被编译的，而 C++11 开始，连续的右尖括号将变得合法，并且能够顺利通过编译。甚至于下下面这种写法都能够通过编译：
 
 ```cpp
 template<bool T> SuckType;
-std::vector<SuckType<(1>2)>> v; // 合法, 但不建议写出这样的代码
+    std::vector<SuckType<(1>2)>> v; // 合法, 但不建议写出这样的代码
 ```
 
 ### 类型别名模板
@@ -599,7 +599,7 @@ using NewType = SuckType<std::vector, std::string>;
 ```cpp
 template<typename T, typename U>
 auto add(T x, U y) -> decltype(x+y) {
-return x+y
+    return x+y
 }
 ```
 
@@ -610,7 +610,7 @@ return x+y
 ```cpp
 template<typename T = int, typename U = int>
 auto add(T x, U y) -> decltype(x+y) {
-return x+y
+    return x+y
 }
 ```
 
@@ -626,9 +626,9 @@ template<typename... Ts> class Magic;
 
 ```cpp
 class Magic<int,
-std::vector<int>,
-std::map<std::string,
-std::vector<int>>> darkMagic;
+            std::vector<int>,
+            std::map<std::string,
+            std::vector<int>>> darkMagic;
 ```
 
 既然是任意形式，所以个数为0的模板参数也是可以的：`class Magic<> nothing;`。
@@ -652,7 +652,7 @@ template<typename... Args> void printf(const std::string &str, Args... args);
 ```cpp
 template<typename... Args>
 void magic(Args... args) {
-std::cout << sizeof...(args) << std::endl;
+    std::cout << sizeof...(args) << std::endl;
 }
 ```
 我们可以传递任意个参数给 `magic` 函数：
@@ -710,14 +710,14 @@ void printf(T0 t0, T... t) {
 // 编译这个代码需要开启 -std=c++14
 template<typename T, typename... Args>
 auto print(T value, Args... args) {
-std::cout << value << std::endl;
-return std::initializer_list<T>{([&] {
-std::cout << args << std::endl;
-}(), value)...};
+    std::cout << value << std::endl;
+    return std::initializer_list<T>{([&] {
+        std::cout << args << std::endl;
+    }(), value)...};
 }
 int main() {
-print(1, 2.1, "123");
-return 0;
+    print(1, 2.1, "123");
+    return 0;
 }
 ```
 
@@ -753,20 +753,20 @@ C++11 引入了委托构造的概念，这使得构造函数可以在同一个
 ```cpp
 class Base {
 public:
-int value1;
-int value2;
-Base() {
-value1 = 1;
-}
-Base(int value) : Base() { // 委托 Base() 构造函数
-value2 = 2;
-}
+    int value1;
+    int value2;
+    Base() {
+        value1 = 1;
+    }
+    Base(int value) : Base() { // 委托 Base() 构造函数
+        value2 = 2;
+    }
 };
 
 int main() {
-Base b(2);
-std::cout << b.value1 << std::endl;
-std::cout << b.value2 << std::endl;
+    Base b(2);
+    std::cout << b.value1 << std::endl;
+    std::cout << b.value2 << std::endl;
 }
 ```
 
@@ -777,23 +777,23 @@ std::cout << b.value2 << std::endl;
 ```cpp
 class Base {
 public:
-int value1;
-int value2;
-Base() {
-value1 = 1;
-}
-Base(int value) : Base() { // 委托 Base() 构造函数
-value2 = 2;
-}
+    int value1;
+    int value2;
+    Base() {
+        value1 = 1;
+    }
+    Base(int value) : Base() { // 委托 Base() 构造函数
+        value2 = 2;
+    }
 };
 class Subclass : public Base {
 public:
-using Base::Base; // 继承构造
+    using Base::Base; // 继承构造
 };
 int main() {
-Subclass s(3);
-std::cout << s.value1 << std::endl;
-std::cout << s.value2 << std::endl;
+    Subclass s(3);
+    std::cout << s.value1 << std::endl;
+    std::cout << s.value2 << std::endl;
 }
 ```
 
@@ -803,10 +803,10 @@ std::cout << s.value2 << std::endl;
 
 ```cpp
 struct Base {
-virtual void foo();
-};
-struct SubClass: Base {
-void foo();
+    virtual void foo();
+    };
+    struct SubClass: Base {
+    void foo();
 };
 ```
 
@@ -859,10 +859,10 @@ C++11 提供了上述需求的解决方案，允许显式的声明采用或拒
 
 ```cpp
 class Magic {
-public:
-Magic() = default; // 显式声明使用编译器生成的构造
-Magic& operator=(const Magic&) = delete; // 显式声明拒绝编译器生成构造
-Magic(int magic_number);
+    public:
+    Magic() = default; // 显式声明使用编译器生成的构造
+    Magic& operator=(const Magic&) = delete; // 显式声明拒绝编译器生成构造
+    Magic(int magic_number);
 }
 ```
 
@@ -874,19 +874,19 @@ C++11 引入了枚举类（enumaration class），并使用 `enum class` 的语
 
 ```cpp
 enum class new_enum : unsigned int {
-value1,
-value2,
-value3 = 100,
-value4 = 100
+    value1,
+    value2,
+    value3 = 100,
+    value4 = 100
 };
 ```
 
 这样定义的枚举实现了类型安全，首先他不能够被隐式的转换为整数，同时也不能够将其与整数数字进行比较，更不可能对不同的枚举类型的枚举值进行比较。但相同枚举值之间如果指定的值相同，那么可以进行比较：
 
 ```cpp
 if (new_enum::value3 == new_enum::value4) {
-// 会输出
-std::cout << "new_enum::value3 == new_enum::value4" << std::endl;
+    // 会输出
+    std::cout << "new_enum::value3 == new_enum::value4" << std::endl;
 }
 ```
 
@@ -899,7 +899,7 @@ std::cout << "new_enum::value3 == new_enum::value4" << std::endl;
 template<typename T>
 std::ostream& operator<<(typename std::enable_if<std::is_enum<T>::value, std::ostream>::type& stream, const T& e)
 {
-return stream << static_cast<typename std::underlying_type<T>::type>(e);
+    return stream << static_cast<typename std::underlying_type<T>::type>(e);
 }
 ```