Reviewed Chapter 7~13; Fixed code-in-book incompletely

Author: cppHusky

.vscode/Test.cpp

@@ -63,6 +63,51 @@
         "iomanip": "cpp",
         "fstream": "cpp",
         "sstream": "cpp",
-        "*.tcc": "cpp"
+        "*.tcc": "cpp",
+        "any": "cpp",
+        "array": "cpp",
+        "barrier": "cpp",
+        "cfenv": "cpp",
+        "chrono": "cpp",
+        "cinttypes": "cpp",
+        "codecvt": "cpp",
+        "complex": "cpp",
+        "condition_variable": "cpp",
+        "coroutine": "cpp",
+        "csetjmp": "cpp",
+        "csignal": "cpp",
+        "cstdarg": "cpp",
+        "cuchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "forward_list": "cpp",
+        "map": "cpp",
+        "unordered_map": "cpp",
+        "expected": "cpp",
+        "functional": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "regex": "cpp",
+        "source_location": "cpp",
+        "string_view": "cpp",
+        "future": "cpp",
+        "latch": "cpp",
+        "mutex": "cpp",
+        "numbers": "cpp",
+        "ranges": "cpp",
+        "scoped_allocator": "cpp",
+        "semaphore": "cpp",
+        "shared_mutex": "cpp",
+        "span": "cpp",
+        "spanstream": "cpp",
+        "stacktrace": "cpp",
+        "stdfloat": "cpp",
+        "stop_token": "cpp",
+        "syncstream": "cpp",
+        "thread": "cpp",
+        "typeindex": "cpp",
+        "variant": "cpp"
     }
 }

.vscode/Test.exe

@@ -1,11 +1,10 @@
-#include "Header.hpp"
+#include "is_same.hpp"
 #include <iostream>
 int main() {
     int (*p1)[3] {}, *p2[3] {};
     std::cout << user::is_same<int(*)[3], int*[3]>() << std::endl //输出0
               << user::is_same<int(&)[3]>(*p1) << std::endl //输出0
-              << user::is_same<int*>(*p1) << std::endl //输出1
-    //提示：函数参数传递过程中发生了int[3]到int*的隐式类型转换
+              << user::is_same<int[3]>(*p1) << std::endl //输出1
               << user::is_same<>(p1, p2) << std::endl; //输出0
     return 0;
 }

.vscode/settings.json

@@ -136,36 +136,55 @@ auto user::array<bool, N>::operator=(const array &arr) -> array& {
     return *this;
 }
 template<std::size_t N>
-constexpr bool& user::array<bool, N>::at(std::size_t pos) {
+constexpr auto user::array<bool, N>::at(std::size_t pos)
+-> reference {
     if (pos >= N)
         pos = N - 1;
     return _elem[pos];
 }
 template<std::size_t N>
-constexpr const bool& user::array<bool, N>::at(std::size_t pos)const {
+constexpr bool user::array<bool, N>::at(std::size_t pos)const {
     if (pos >= N)
         pos = N - 1;
     return _elem[pos];
 }
 template<std::size_t N>
-constexpr bool& user::array<bool, N>::operator[](std::size_t pos) {
+constexpr auto user::array<bool, N>::operator[](std::size_t pos)
+-> reference {
     return _elem[pos];
 }
 template<std::size_t N>
-constexpr const bool& user::array<bool, N>::operator[](std::size_t pos)const {
+constexpr bool user::array<bool, N>::operator[](std::size_t pos)const {
     return _elem[pos];
 }
 template<std::size_t N>
 void user::array<bool, N>::fill(bool val) {
     for (std::size_t i = 0; i < N; i++)
         _elem[i] = val;
 }
-//比较运算符和get函数均无需再重载
+template<std::size_t I, std::size_t N>
+typename std::bitset<N>::reference user::get(array<bool, N> &arr) {
+    return arr._elem[I];
+}
+template<std::size_t I, std::size_t N>
+const bool user::get(const array<bool, N> &arr) {
+    return arr._elem[I];
+}
+template<std::size_t N>
+constexpr bool user::operator<(
+    const array<bool, N> &lhs, const array<bool, N> &rhs
+) {
+   return lhs._elem.to_string() < rhs._elem.to_string();
+} //这里我们可以用std::bitset的to_string成员函数，转换成std::string再比较
+//其它比较运算符无需再重载
 template<std::size_t N, std::size_t M>
 void user::swap(array<bool, N> &lhs, array<bool, M> &rhs) {
     constexpr std::size_t minlen {std::min(N, M)};
-    for (std::size_t i = 0; i < minlen; i++)
-        std::swap(lhs._elem[i], rhs._elem[i]);
+    for (std::size_t i = 0; i < minlen; i++){
+        bool tmp {lhs._elem[i]};
+        lhs._elem[i] = rhs._elem[i];
+        rhs._elem[i] = tmp;
+    }
 }
 template<std::size_t N> //类模板参数
 template<std::size_t M> //函数模板参数

code_in_book/11.2-11.3/main.cpp

@@ -4,31 +4,42 @@ 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 I, std::size_t N> //模板参数与另一个不同，所以它是一个重载
+typename std::bitset<N>::reference get(array<bool, N>&);
+template<std::size_t I, std::size_t N>
+const bool get(const array<bool, N>&);
+template<std::size_t N, std::size_t M> //它也是函数模板重载
 void swap(array<bool, N>&, array<bool, M>&);
 template<std::size_t N>
+constexpr bool operator<(
+    const array<bool, N>&, const array<bool, N>&
+); //这个是专门为bool数组比较而设计的，因为std::bitset没有迭代器这个概念
+//模板定义部分
+template<std::size_t N>
 class array<bool, N> { //定义array<bool,N>部分特化
     std::bitset<N> _elem; //std::bitset可以更方便地解决我们的问题
 public:
+    using reference = typename std::bitset<N>::reference;
+    //类型别名，方便我们使用reference
     array(std::initializer_list<bool>); //构造函数
     array(const array&); //拷贝构造函数，这里的array是array<bool,N>
     array& operator=(const array&); //赋值运算符
-    constexpr bool& at(std::size_t);
-    constexpr const bool& at(std::size_t)const;
-    constexpr bool& operator[](std::size_t);
-    constexpr const bool& operator[](std::size_t)const;
-    constexpr bool& front() { return _elem[0]; } //std::bitset支持下标运算符
-    constexpr const bool& front()const { return _elem[0]; }
-    constexpr bool& back() { return _elem[N - 1]; }
-    constexpr const bool& back()const { return _elem[N - 1]; }
+    constexpr reference at(std::size_t);
+    constexpr bool at(std::size_t)const;
+    constexpr reference operator[](std::size_t);
+    constexpr bool operator[](std::size_t)const;
+    constexpr reference front() { return _elem[0]; } //std::bitset支持下标
+    constexpr bool front()const { return _elem[0]; }
+    constexpr reference back() { return _elem[N - 1]; }
+    constexpr bool back()const { return _elem[N - 1]; }
     constexpr bool empty()const { return !N; }
     constexpr std::size_t size()const { return N; }
-    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
-    //声明模板友元，所有的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>&);
+    void fill(bool); //对于bool类型来说，传值比传常量引用更省内存空间
+    template<std::size_t I, std::size_t M>
+    friend typename std::bitset<M>::reference get(array<bool, M>&);
+    //声明模板友元，所有的get<I,M>函数实例都是类实例array<bool,N>的友元
+    template<std::size_t I, std::size_t M>
+    friend const bool get(const array<bool, M>&);
     //同上
     template<std::size_t N1, std::size_t N2>
     friend void swap(array<bool, N1>&, array<bool, N2>&);
@@ -37,5 +48,9 @@ public:
     //声明友元类模板，任何一个array实例都是array<bool,N>的友元
     template<std::size_t M>
     void swap(array<bool, M>&);
-}; //其中有些友元不需要重新定义（因为特化也是原模板的一部分），但有些需要
+    template<std::size_t M>
+    friend constexpr bool operator<(
+        const array<bool, M>&, const array<bool, M>&
+    );
+};
 }; //end namespace user

code_in_book/11.4-11.6/Definition.tpp

@@ -23,7 +23,6 @@ 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,6 +58,9 @@ class array {
     template<std::size_t M>
     void swap(array<T, M>&);
     //作为array<T,N>的成员函数，它可与array<T,M>对象交换
+    template<typename U, std::size_t M>
+    friend constexpr bool operator<(const array<U,M>&, const array<U,M>&);
+    //这里也用到了一些array的私有成员，所以它需要是友元
 };
 }; //end namespace user
 #include "Specification.tpp" //包含Specification.tpp文件的代码

code_in_book/11.4-11.6/Specification.tpp

@@ -10,7 +10,8 @@ std::ostream& user::operator<<(
     std::ostream &out,
     const user::unique_ptr<T> &ptr
 ) {
-    return out << ptr._ptr; //其实就是直接输出ptr内部的指针值，这也正是我们想要的
+    return out << ptr._ptr;
+    //其实就是直接输出ptr内部的指针值，这也正是我们想要的
 }
 //主模板成员函数定义部分
 template<typename T>

code_in_book/11.4-11.6/array.hpp

@@ -18,7 +18,7 @@ class unique_ptr { //分配动态单对象，使用unique_ptr<T>语法
     using pointer = T*; //通过using定义成员类型pointer，公有
     using element_type = T; //定义成员类型element_type
 private:
-    pointer _ptr {nullptr}; //pointer类型的私有成员，成员类型pointer必须定义在前面
+    pointer _ptr {nullptr}; //pointer类私有成员，成员类型pointer必须定义在前面
     static std::unordered_set<pointer> record;
 public:
     explicit unique_ptr(pointer = {nullptr}); //接收pointer类参数，或nullptr

code_in_book/11.8-11.9/Definition.tpp

@@ -162,7 +162,7 @@ \subsubsection*{加法运算符的重载}
         v._arr[i] = _arr[i] + n; //这两个_arr成员不是同一个东西
     return v; //返回值是v
 }
-\end{lstlisting}
+\end{lstlisting}\pagebreak
 读者可能关心以下几个问题，我将逐一说明：\par
 {\kaishu 为什么重载的加法运算符只接收了一个参数？不是说，成员函数接收的操作数个数不变吗？}\par
 我们在下一节中会讲到，任何一个成员函数都带有一个隐藏参数，即``调用此函数的对象''。以 \lstinline@size@ 成员函数为例，当我们调用它的时候，比如写成 \lstinline@_arr.size()@。这里看似不需要传递参数；但在汇编代码中我们就可以看出，实际上这个过程把 \lstinline@_arr@ 以指针（或引用）的形式传递过去了。\par
@@ -178,7 +178,7 @@ \subsubsection*{加法运算符的重载}
     v._size = std::min(_size, a._size);
 \end{lstlisting}
 它有三个 \lstinline@_size@ 成员出现。\lstinline@v._size@ 和 \lstinline@a._size@ 分别是 \lstinline@v@ 和 \lstinline@a@ 的成员，这个不会搞混吧。而 \lstinline@_size@ 正是``调用此运算符的对象''的成员。\par
-如果放在 \lstinline@arr1+arr2@ 的情境下，那么 \lstinline@_size@, \lstinline@a._size@ 和 \lstinline@v._size@ 分别对应 \lstinline@arr1._size@\footnote{这只是象怔性的写法，实际上 \lstinline@arr1._size@ 的写法相当于在 \lstinline@valarri@ 的类作用域外部访问该类的私有成员，这是禁止的。}, \lstinline@arr2._size@ 和 \lstinline@(arr1+arr2)._size@\footnote{初学者可能对 \lstinline@(arr1+arr2)._size@ 这种写法感到困惑，但是不要忘记，\lstinline@arr1+arr2@ 的返回值也是一个 \lstinline@valarri@ 类型的对象，所以它当然也有自己的成员咯。}。图8.1展示了它们之间的关系。\par
+如果放在 \lstinline@arr1+arr2@ 的情境下，那么 \lstinline@_size@, \lstinline@a._size@ 和 \lstinline@v._size@ 分别对应 \lstinline@arr1._size@\footnote{这只是象怔性的写法，实际上 \lstinline@arr1._size@ 的写法相当于在 \lstinline@valarri@ 的类作用域外部访问该类的私有成员，这是禁止的。}, \lstinline@arr2._size@ 和 \lstinline@(arr1+arr2)._size@\footnote{初学者可能对 \lstinline@(arr1+arr2)._size@ 这种写法感到困惑，但是不要忘记，\lstinline@arr1+arr2@ 的返回值也是一个\\\lstinline@valarri@ 类型的对象，所以它当然也有自己的成员咯。}。图8.1展示了它们之间的关系。\par
 \begin{figure}[htbp]
     \centering
     \includegraphics[width=\textwidth]{../images/generalized_parts/08_operator_overloading_as_member_function.drawio.png}
@@ -227,7 +227,7 @@ \subsubsection*{\texttt{this}指针与赋值运算符的重载}
 \begin{lstlisting}
     arr1 = arr1; //这是需要特殊考虑的！
 \end{lstlisting}
-如果进行了自我赋值，那就应该什么也不做直接返回 \lstinline@*this@，否则就是在浪费时间。
+如果进行了自我赋值，那就应该什么也不做直接返回 \lstinline@*this@，否则就是在浪费时间。\pagebreak
 \begin{lstlisting}
 valarri& valarri::operator=(const valarri &a) { //其中的a应作为常量引用
     if (&a == this) //检测a的地址是否与本对象一致