Updated to Chapter 11, Section 5; Renamed images

Author: cppHusky

Structure.md

@@ -777,12 +777,6 @@
 
 `is_same` 类模板等。
 
-### 实操：智能指针
-
-带读者写一个`auto_ptr`类模板。
-
-> 虽然`auto_ptr`在C++17中已经被移除了，但是我们泛讲篇不需要考虑得太细，能写出来一个简单的`auto_ptr`对初学者来说就已经是不小的成就了。
-
 ### STL简介
 
 #### 容器
@@ -793,12 +787,20 @@
 
 简单介绍下迭代器。
 
+#### 函数对象
+
 #### 算法
 
 带读者试试`copy`, `sort`, `unique`三种算法。
 
 > 更多STL知识及相关概念放精讲篇了，要不然泛讲篇就变成精讲篇了。
 
+### 实操：智能指针
+
+带读者写一个`auto_ptr`类模板。
+
+> 虽然`auto_ptr`在C++17中已经被移除了，但是我们泛讲篇不需要考虑得太细，能写出来一个简单的`auto_ptr`对初学者来说就已经是不小的成就了。
+
 ## 异常处理简介
 
 > 本章只做简单介绍，详细的放精讲篇。

code_in_book/11.4-11.6/Definition.tpp

@@ -1,6 +1,6 @@
-#pragma once
-#include "array.hpp"
-#include <algorithm>
+#pragma once //千万不要遗漏
+#include "array.hpp" //这句可以没有，但是为了编译器检查方便，还是包含一下吧
+#include <algorithm> //包含std::min等实用函数
 //类模板std::array<T,N>的成员函数及一些非成员函数的定义
 template<typename T, std::size_t N>
 user::array<T, N>::array(std::initializer_list<T> ilist) : _elem{} {
@@ -111,6 +111,7 @@ void user::swap(array<T, N> &lhs, array<T, M> &rhs) {
     for (std::size_t i = 0; i < minlen; i++)
         std::swap(lhs._elem[i], rhs._elem[i]); //可以访问私有成员
 }
+
 //类模板特化std::array<bool,N>的成员函数及部分相关非成员函数的定义
 template<std::size_t N>
 user::array<bool, N>::array(std::initializer_list<bool> ilist) : _elem {} {

code_in_book/11.4-11.6/Specification.tpp

@@ -1,11 +1,11 @@
-#pragma once
-#include "array.hpp"
-#include <bitset>
+#pragma once //千万不要遗漏
+#include "array.hpp" //这句可以没有，但是为了编译器检查方便，还是包含一下吧
+#include <bitset> //user::array内部的数据需要利用std::bitset来管理
 namespace user{
 //array类模板特化部分
 template<std::size_t N>
 class array<bool, N>; //特化的声明
-template<std::size_t N, std::size_t M>
+template<std::size_t N, std::size_t M> //模板参数与另一个不同，所以它是一个重载
 void swap(array<bool, N>&, array<bool, M>&);
 template<std::size_t N>
 class array<bool, N> { //定义array<bool,N>部分特化
@@ -24,14 +24,14 @@ public:
     constexpr const bool& back()const { return _elem[N - 1]; }
     constexpr bool empty()const { return !N; }
     constexpr std::size_t size()const { return N; }
-    void fill(bool); //传值比传常量引用更省内存空间
+    void fill(bool); //对于bool来说，传值比传常量引用更省内存空间
     template<std::size_t I, typename U, std::size_t M>
-    friend U& get(array<U, M>&); //这里不建议把U改成bool，因为U不是T
+    friend U& get(array<U, M>&); //不建议把U改成bool，因为U不是T
     //声明模板友元，所有的get<U,M>函数实例都是类实例array<bool,N>的友元
     template<std::size_t I, typename U, std::size_t M>
     friend const U& get(const array<U, M>&);
     //同上
-    template<std::size_t N, std::size_t M> //模板参数变化，所以它是一个重载
+    template<std::size_t N, std::size_t M>
     friend void swap(array<bool, N>&, array<bool, M>&);
     template<typename, std::size_t>
     friend class array;

code_in_book/11.4-11.6/array.hpp

@@ -23,6 +23,7 @@ template<typename T, std::size_t N>
 constexpr bool operator==(const array<T, N>&, const array<T, N>&);
 template<typename T, std::size_t N>
 constexpr bool operator!=(const array<T, N>&, const array<T, N>&);
+
 //类模板定义部分
 template<typename T, std::size_t N>
 class array {
@@ -59,7 +60,6 @@ class array {
     void swap(array<T, M>&);
     //作为array<T,N>的成员函数，它可与array<T,M>对象交换
 };
-//#include "Specialization_of_bool.hpp"
 }; //end namespace user
-#include "Specification.tpp"
-#include "Definition.tpp"
+#include "Specification.tpp" //包含Specification.tpp文件的代码
+#include "Definition.tpp" //同上

code_in_book/11.7/remove_duplicate.cpp

@@ -0,0 +1,19 @@
+#include <iostream>
+#include <list>
+#include <set>
+int main() {
+    std::list<char> chs {'c', 'a', 'a', 'b', 'd', 'b', 'a', 'e'};
+    std::set<char> s; //一个集合，用来表示chs中存在哪些数据
+    auto it = chs.begin(); //它是一个迭代器类型，我们把它当作指针看待就好
+    while (it != chs.end()) {
+        if (s.find(*it) == s.end()) { //*it表示it当前指向的chs元素
+            s.insert(*it); //s中没有记录*it这个数据，那就把它存进s
+            ++it; //it指向下一个元素
+        }
+        else //否则，就说明此前已经有*it这个数据了，当前的元素与前面重复
+            it = chs.erase(it); //删除it指向的元素，并让it指向下一个元素
+    }
+    for (auto ch : chs)
+        std::cout << ch << ' ';
+    return 0;
+}

generalized_parts/01_welcome_to_cpp/01_start_with_a_cpp_program.tex

@@ -10,7 +10,7 @@ \section{开始一个C++程序}
 \end{enumerate}
 \begin{figure}[htbp]
     \centering
-    \includegraphics[width=0.8\textwidth]{../images/generalized_parts/01_From_source_code_to_executable_300.png}
+    \includegraphics[width=0.8\textwidth]{../images/generalized_parts/01_From_source_code_to_executable.png}
     \caption{从源代码到可执行文件}
 \end{figure}
 实际上的过程会更复杂，比如在编译之前还会进行预处理（Preprocess）。但是我们现在还不需要操心这么多，因为在按下``编译''键之后，预处理和编译都会进行，所以不妨把它统称为一个过程。\par

generalized_parts/01_welcome_to_cpp/04_operators_and_types.tex

@@ -66,4 +66,4 @@ \subsection*{整数除法问题}
     cout << a / b * 1.; //计算a/b的浮点数结果，但事与愿违
 \end{lstlisting}
 关于第一种方法为什么可行，第二种为什么不可行，我们会在第二章中探讨。\par
-总而言之，类型不同，可能会让结果出现一些意想不到的差异。因此类型是很重要的数据特怔，日后编程时我们需要多加留意。\par
+总而言之，类型不同，可能会让结果出现一些意想不到的差异。因此类型是很重要的数据特征，日后编程时我们需要多加留意。\par

generalized_parts/01_welcome_to_cpp/05_sizeof_and_memory.tex

@@ -15,7 +15,7 @@ \subsection*{内存如何存储数据？}
 回到我们刚才的比喻。存储器的内部结构是排列有序的房屋。每个房屋代表一个字节，它是相对独立的最小可寻址单元。而每个房屋有8个房间，各自存储一比特的信息。图1.3可以帮助我们更直观地理解这种关系。\par
 \begin{figure}[htbp]
     \centering
-    \includegraphics[width=0.75\textwidth]{../images/generalized_parts/01_Memory_byte_and_bit_300.png}
+    \includegraphics[width=0.75\textwidth]{../images/generalized_parts/01_Memory_byte_and_bit.png}
     \caption{存储器、字节与比特}
 \end{figure}
 \subsection*{信息与容量}

generalized_parts/02_basic_operation_on_data/03_operators.tex

@@ -65,7 +65,7 @@ \subsection*{运算符的优先级}
 C++中的赋值运算符优先级很低，比四则运算都要低。那么按照我们的思路，如果加法，乘法和赋值运算符同时出现，我们应该先给乘法套括号，然后是加法，最后才是赋值。如图2.1所示。\par
 \begin{figure}[htbp]
     \centering
-    \includegraphics[width=0.5\textwidth]{../images/generalized_parts/02_Precedence_of_multiply_addition_and_assignment_300.png}
+    \includegraphics[width=0.5\textwidth]{../images/generalized_parts/02_Precedence_of_multiply_addition_and_assignment.png}
     \caption{代码 \lstinline@num=a*b+c*d;@ 的套括号解释}
 \end{figure}
 再看这段代码：
@@ -103,7 +103,7 @@ \subsection*{运算符的结合性}
 除法运算符所在的优先级，其结合性是从左向右的，所以在乘法、除法和取模混合运算时，它就会从左向右套括号，而直观表现上就是``从左向右算''。赋值运算符所在的优先级，其结合性是从右向左的，所以在连续赋值的时候，它就会从右向左套括号，而直观表现上就是``从右向左算''。\par
 \begin{figure}[htbp]
     \centering
-    \includegraphics[width=0.4\textwidth]{../images/generalized_parts/02_Associativity_of_division_and_assignment_300.png}
+    \includegraphics[width=0.4\textwidth]{../images/generalized_parts/02_Associativity_of_division_and_assignment.png}
     \caption{除法运算符和赋值运算符的结合性}
 \end{figure}
 所以连续除法中 \lstinline@8/4/2@ 就应该解释成 \lstinline@(8/4)/2@ 而非 \lstinline@8/(4/2)@；而连续赋值中 \lstinline@a=b=0@ 就应该解释成 \lstinline@a=(b=0)@ 而非 \lstinline@(a=b)=0@。如图2.2所示。\par

generalized_parts/02_basic_operation_on_data/04_type_cast.tex

@@ -30,7 +30,7 @@ \subsection*{隐式类型转换}
 接下来是这个 \lstinline@double@ 型的 \lstinline@1.*a@ 作为整体与 \lstinline@int@ 型的 \lstinline@b@ 相除，于是 \lstinline@int@ 型的 \lstinline@b@ 也需要被转换成 \lstinline@double@ 型数据再参与运算。而 \lstinline@double@ 型数据的除法就不致于有截尾级别的精度损失了。整个过程如图2.3(a)所示。\par
 \begin{figure}[htbp]
     \centering
-    \includegraphics[width=0.95\textwidth]{../images/generalized_parts/02_Implicit_type_cast_from_int_to_double_300.png}
+    \includegraphics[width=0.95\textwidth]{../images/generalized_parts/02_Implicit_type_cast_from_int_to_double.png}
     \caption{\lstinline@1.*a/b@ 与 \lstinline@a/b*1.@ 的隐式类型转换过程图解}
 \end{figure}
 那么我写成这样行不行呢？
@@ -52,7 +52,7 @@ \subsection*{隐式类型转换}
 \textbf{布尔转换（Boolean Conversions）}是隐式类型转换当中比较特殊，而又十分常用的一类转换。如图2.4所示，它的转换规则很简单：如果别的基本数据类型要转换为 \lstinline@bool@ 类型的话，\lstinline@0@ 会转换成 \lstinline@false@，而其它的所有数都会被转换成 \lstinline@true@；如果 \lstinline@bool@ 类型要转换成其它的基本数据类型的话，\lstinline@false@ 会转换成 \lstinline@0@，而 \lstinline@true@ 会转换成 \lstinline@1@。\par
 \begin{figure}[htbp]
     \centering
-    \includegraphics[width=0.7\textwidth]{../images/generalized_parts/02_boolean_conversion_300.png}
+    \includegraphics[width=0.7\textwidth]{../images/generalized_parts/02_boolean_conversion.png}
     \caption{布尔转换规则}
 \end{figure}
 \subsection*{显式类型转换}
@@ -97,7 +97,7 @@ \subsection*{显式类型转换}
 在这里，乘法运算符在面临一个 \lstinline@int@ 操作数和 \lstinline@double@ 操作数的时候，它会怎么做呢？如图2.5所示，它将把 \lstinline@int@ 通过隐式类型转换变为 \lstinline@double@ 型！这样一来我们就白干了。\par
 \begin{figure}[htbp]
     \centering
-    \includegraphics[width=0.6\textwidth]{../images/generalized_parts/02_Explicit_type_cast_from_double_to_int_in_vain_300.png}
+    \includegraphics[width=0.6\textwidth]{../images/generalized_parts/02_Explicit_type_cast_from_double_to_int_in_vain.png}
     \caption{显式类型转换，但是又被隐式类型转换改回去了}
 \end{figure}
 总而言之，类型转换是一个非常复杂的话题。限于我们目前接触到的类型尚少，这里只作简单概括。将来我们接触复合类型和自定义类型的时候，还会对此作针对性讲解的。\par