rm error tokens

notes/ch09.md

@@ -126,7 +126,7 @@
 
 ### 特殊的forwad_list操作
 
-- 链表在删除元素时需要修改前置节点的内容，双向链表会前驱的指针，但是单向链表没有保存，因此需要增加获取前置节点的方法。
+- 链表在删除元素时需要修改前置节点的内容，双向链表会前驱的指针，但是单向链表没有保存，因此需要增加获取前置节点的方法。
 - `forward_list`定义了`before_begin`，即首前（off-the-begining）迭代器，允许我们再在首元素之前添加或删除元素。
 
 | 操作 | 解释 |
@@ -138,7 +138,7 @@
 | `lst.insert_after(p, b, e)` | 在迭代器`p`之后插入元素。由迭代器`b`和`e`指定范围。 |
 | `lst.insert_after(p, il)` | 在迭代器`p`之后插入元素。由`il`指定初始化列表。 |
 | `emplace_after(p, args)` | 使用`args`在`p`之后的位置，创建一个元素，返回一个指向这个新元素的迭代器。若`p`为尾后迭代器，则函数行为未定义。 |
-| `lst.erase_after(p)` | 删除`p`指向位置之后的元素，返回一个指向被删元素之后的元素的迭代器，若`p`指向`lst`的尾元素或者是一个尾后迭代器，则函数行为未定义。 |
+| `lst.erase_after(p)` | 删除`p`指向位置之后的元素，返回一个指向被删元素之后的元素的迭代器，若`p`指向`lst`的尾元素或者是一个尾后迭代器，则函数行为未定义。 |
 | `lst.erase_after(b, e)` | 类似上面，删除对象换成从`b`到`e`指定的范围。 |
 
 ### 改变容器大小
@@ -230,9 +230,9 @@
 
 | 操作 | 解释 |
 |-----|-----|
-| `s.substr(pos, n)` | 返回一个`string`，包含`s`中从`pos`开始的`n`个字符的拷贝。`pos`的默认值是0，`n`的默认值是`s.size() - pos`，即拷贝从`pos`开始的所有字符。 |
+| `s.substr(pos, n)` | 返回一个`string`，包含`s`中从`pos`开始的`n`个字符的拷贝。`pos`的默认值是0，`n`的默认值是`s.size() - pos`，即拷贝从`pos`开始的所有字符。 |
 
-### 改变string的其他方法
+### 改变string的其他方法
 
 | 操作 | 解释 |
 |-----|-----|
@@ -245,7 +245,7 @@
 ### string搜索操作
 
 - `string`类提供了6个不同的搜索函数，每个函数都有4个重载版本。
-- 每个搜索操作都返回一个`string::size_type`值，表示匹配发生位置的下标。如果搜索失败则返回一个名为`string::npos`的`static`成员（类型是`string::size_type`，初始化值是-1，也就是`string`最大的可能大小）。
+- 每个搜索操作都返回一个`string::size_type`值，表示匹配发生位置的下标。如果搜索失败则返回一个名为`string::npos`的`static`成员（类型是`string::size_type`，初始化值是-1，也就是`string`最大的可能大小）。
 
 | 搜索操作 | 解释 |
 |-----|-----|
@@ -280,7 +280,7 @@ args必须是一下的形式之一：
 
 ### string和数值转换
 
-| 转换 | 解释 |
+| 转换 | 解释 |
 |-----|-----|
 | `to_string(val)` | 一组重载函数，返回数值`val`的`string`表示。`val`可以使任何算术类型。对每个浮点类型和`int`或更大的整型，都有相应版本的`to_string()`。和往常一样，小整型会被提升。 |
 | `stoi(s, p, b)` | 返回`s`起始子串（表示整数内容）的数值，`p`是`s`中第一个非数值字符的下标，默认是0，`b`是转换所用的基数。返回`int` |
@@ -300,7 +300,7 @@ args必须是一下的形式之一：
 
 ### 适配器的通用操作和类型
 
-| 操作 | 解释 |
+| 操作 | 解释 |
 |-----|-----|
 | `size_type` | 一种类型，须以保存当前类型的最大对象的大小 |
 | `value_type` | 元素类型 |
@@ -319,7 +319,7 @@ args必须是一下的形式之一：
 |-----|-----|
 | `s.pop()` | 删除栈顶元素，不返回。 |
 | `s.push(item)` | 创建一个新元素，压入栈顶，该元素通过拷贝或移动`item`而来 |
-| `s.emplace(args)` | 同上，但元素由`args`来构造。 |
+| `s.emplace(args)` | 同上，但元素由`args`来构造。 |
 | `s.top()` |  返回栈顶元素，不删除。|
 
 - 定义在`stack`头文件中。
@@ -338,4 +338,4 @@ args必须是一下的形式之一：
 
 - 定义在`queue`头文件中。
 - `queue`默认基于`deque`实现，`priority_queue`默认基于`vector`实现。
-- `queue`可以在`list`或`vector`之上实现，`priority_queue`也可以用`deque`实现。
+- `queue`可以在`list`或`vector`之上实现，`priority_queue`也可以用`deque`实现。

notes/ch10.md

@@ -58,7 +58,7 @@
 
 - 谓词（`predicate`）：
   - 是一个**可调用的表达式**，返回结果是一个能用作条件的值
-  - 一元谓词：接受一个参数
+  - 一元谓词：接受一个参数
   - 二元谓词：接受两个参数
 
 - 例子：
@@ -91,17 +91,17 @@
 - 默认情况下，从`lambda`生成的类都包含一个对应该`lambda`所捕获的变量的数据成员，在`lambda`对象创建时被初始化。
 - **值捕获**：前提是变量可以拷贝，`size_t v1 = 42; auto f = [v1] {return v1;};`。
 - **引用捕获**：必须保证在`lambda`执行时，变量是存在的，`auto f2 = [&v1] {return v1;};`
-- 尽量减少捕获的数据量，尽可能避免捕获指针或引用。
+- 尽量减少捕获的数据量，尽可能避免捕获指针或引用。
 - **隐式捕获**：让编译器推断捕获列表，在捕获列表中写一个`&`（引用方式）或`=`（值方式）。`auto f3 = [=] {return v1;}`
 
 **lambda捕获列表**：
 
 | 捕获列表 | 解释 |
 |-----|-----|
 | `[]` | 空捕获列表。`lambda`不能使用所在函数中的变量。一个`lambda`只有在捕获变量后才能使用它们。 |
-| `[names]` | `names`是一个逗号分隔的名字列表，这些名字都是在`lambda`所在函数的局部变量，捕获列表中的变量都被拷贝，名字前如果使用了`&`，则采用引用捕获方式。 |
-| `[&]` | 隐式捕获列表，采用引用捕获方式。`lambda`体中所使用的来自所在函数的实体都采用引用方式使用。 |
-| `[=]` | 隐式捕获列表，采用值捕获方式。 |
+| `[names]` | `names`是一个逗号分隔的名字列表，这些名字都是在`lambda`所在函数的局部变量，捕获列表中的变量都被拷贝，名字前如果使用了`&`，则采用引用捕获方式。 |
+| `[&]` | 隐式捕获列表，采用引用捕获方式。`lambda`体中所使用的来自所在函数的实体都采用引用方式使用。 |
+| `[=]` | 隐式捕获列表，采用值捕获方式。 |
 | `[&, identifier_list]` | `identifier_list`是一个逗号分隔的列表，包含0个或多个来自所在函数的变量。这些变量采用值捕获方式，而任何隐式捕获的变量都采用引用方式捕获。`identifier_list`中的名字前面不能使用`&` |
 | `[=, identifier_list]` | `identifier_list`中的变量采用引用方式捕获，而任何隐式捕获的变量都采用值方式捕获。`identifier_list`中的名字不能包括`this`，且前面必须使用`&` |
 
@@ -144,7 +144,7 @@
 
 | 操作 | 解释 |
 |-----|-----|
-| `istream_iterator<T> in(is);` | `in`从输入流`is`读取类型为`T`的值 |
+| `istream_iterator<T> in(is);` | `in`从输入流`is`读取类型为`T`的值 |
 |`istream_iterator<T> end;`  | 读取类型是`T`的值的`istream_iterator`迭代器，表示尾后位置 |
 | `in1 == in2` | `in1`和`in2`必须读取相同类型。如果他们都是尾后迭代器，或绑定到相同的输入，则两者相等。 |
 | `in1 != in2` | 类似上条 |
@@ -157,14 +157,14 @@
 | 操作 | 解释 |
 |-----|-----|
 | `ostream_iterator<T> out(os);` | `out`将类型为`T`的值写到输出流`os`中 |
-| `ostream_iterator<T> out(os, d);` | `out`将类型为`T`的值写到输出流`os`中，每个值后面都输出一个`d`。`d`指向一个空字符结尾的字符数组。 |
+| `ostream_iterator<T> out(os, d);` | `out`将类型为`T`的值写到输出流`os`中，每个值后面都输出一个`d`。`d`指向一个空字符结尾的字符数组。 |
 | `out = val` | 用`<<`运算符将`val`写入到`out`所绑定的`ostream`中。`val`的类型必须和`out`可写的类型兼容。 |
-| `*out, ++out, out++` | 这些运算符是存在的，但不对`out`做任何事情。每个运算符都返回`out`。 |
+| `*out, ++out, out++` | 这些运算符是存在的，但不对`out`做任何事情。每个运算符都返回`out`。 |
 
 ### 反向迭代器
 
 - 反向迭代器就是在容器中从尾元素向首元素反向移动的迭代器。
-- 对于反向迭代器，递增和递减的操作含义会颠倒。
+- 对于反向迭代器，递增和递减的操作含义会颠倒。
 - 实现向后遍历，配合`rbegin`和`rend`。
 
 ## 泛型算法结构
@@ -186,7 +186,7 @@
 - `alg(beg, end, beg2, other args);`
 - `alg(beg, end, beg2, end2, other args);`
 
-其中，`alg`是算法名称，`beg`和`end`表示算法所操作的输入范围。`dest`、`beg2`、`end2`都是迭代器参数，是否使用要依赖于执行的操作。
+其中，`alg`是算法名称，`beg`和`end`表示算法所操作的输入范围。`dest`、`beg2`、`end2`都是迭代器参数，是否使用要依赖于执行的操作。
 
 ### 算法命名规范
 
@@ -202,7 +202,7 @@
 
 | 操作 | 解释 |
 |-----|-----|
-| `lst.merge(lst2)` | 将来自`lst2`的元素合并入`lst`，二者都必须是有序的，元素将从`lst2`中删除。 |
+| `lst.merge(lst2)` | 将来自`lst2`的元素合并入`lst`，二者都必须是有序的，元素将从`lst2`中删除。 |
 | `lst.merge(lst2, comp)` | 同上，给定比较操作。 |
 | `lst.remove(val)` | 调用`erase`删除掉与给定值相等(==)的每个元素 |
 | `lst.remove_if(pred)` | 调用`erase`删除掉令一元谓词为真的每个元素 |
@@ -220,6 +220,6 @@
 |-----|-----|
 | `(p, lst2)` | `p`是一个指向`lst`中元素的迭代器，或者一个指向`flst`首前位置的迭代器。函数将`lst2`中的所有元素移动到`lst`中`p`之前的位置或是`flst`中`p`之后的位置。将元素从`lst2`中删除。`lst2`的类型必须和`lst`相同，而且不能是同一个链表。 |
 | `(p, lst2, p2)` | 同上，`p2`是一个指向`lst2`中位置的有效的迭代器，将`p2`指向的元素移动到`lst`中，或将`p2`之后的元素移动到`flst`中。`lst2`可以是于`lst`或`flst`相同的链表。 |
-| `(p, lst2, b, e)` | `b`和`e`表示`lst2`中的合法范围。将给定范围中的元素从`lst2`移动到`lst`或`first`中。`lst2`与`lst`可以使相同的链表，但`p`不能指向给定范围中的元素。 |
+| `(p, lst2, b, e)` | `b`和`e`表示`lst2`中的合法范围。将给定范围中的元素从`lst2`移动到`lst`或`first`中。`lst2`与`lst`可以使相同的链表，但`p`不能指向给定范围中的元素。 |
 
 - 使用`lst.splice(args)`或`flst.splice_after(args)`

notes/ch12.md

@@ -45,7 +45,7 @@
 | `p.unique()` | 若`p.use_count()`是1，返回`true`；否则返回`false` |
 | `p.use_count()` | 返回与`p`共享对象的智能指针数量；可能很慢，主要用于调试。 |
 
-- **使用动态内存的三种原因**：
+- **使用动态内存的三种原因**：
   - 程序不知道自己需要使用多少对象（比如容器类）。
   - 程序不知道所需要对象的准确类型。
   - 程序需要在多个对象间共享数据。
@@ -60,7 +60,7 @@
   - 接受一个指针，指向要释放的对象。
   - `delete`后的指针称为空悬指针（dangling pointer）。
 - 使用`new`和`delete`管理动态内存存在三个常见问题：
-  - 1.忘记`delete`内存。
+  - 1.忘记`delete`内存。
   - 2.使用已经释放掉的对象。
   - 3.同一块内存释放两次。
 - 坚持只使用智能指针可以避免上述所有问题。
@@ -74,7 +74,7 @@
 | `shared_ptr<T> p(q)` | `p`管理内置指针`q`所指向的对象；`q`必须指向`new`分配的内存，且能够转换为`T*`类型 |
 | `shared_ptr<T> p(u)` | `p`从`unique_ptr u`那里接管了对象的所有权；将`u`置为空 |
 | `shared_ptr<T> p(q, d)` | `p`接管了内置指针`q`所指向的对象的所有权。`q`必须能转换为`T*`类型。`p`将使用可调用对象`d`来代替`delete`。 |
-| `shared_ptr<T> p(p2, d)` | `p`是`shared_ptr p2`的拷贝，唯一的区别是`p`将可调用对象`d`来代替`delete`。 |
+| `shared_ptr<T> p(p2, d)` | `p`是`shared_ptr p2`的拷贝，唯一的区别是`p`将可调用对象`d`来代替`delete`。 |
 | `p.reset()` | 若`p`是唯一指向其对象的`shared_ptr`，`reset`会释放此对象。若传递了可选的参数内置指针`q`，会令`p`指向`q`，否则会将`p`置空。若还传递了参数`d`，则会调用`d`而不是`delete`来释放`q`。 |
 | `p.reset(q)` | 同上 |
 | `p.reset(q, d)` | 同上 |
@@ -83,7 +83,7 @@
 
 - 如果使用智能指针，即使程序块由于异常过早结束，智能指针类也能确保在内存不需要的时候将其释放。
 - **智能指针陷阱**：
-  - 不用相同的内置指针初始化（或`reset`）多个智能指针
+  - 不用相同的内置指针初始化（或`reset`）多个智能指针
   - 不`delete get()`返回的指针。
   - 如果你使用`get()`返回的指针，记得当最后一个对应的智能指针销毁后，你的指针就无效了。
   - 如果你使用智能指针管理的资源不是`new`分配的内存，记住传递给它一个删除器。
@@ -92,15 +92,15 @@
 
 - 某一个时刻只能有一个`unique_ptr`指向一个给定的对象。
 - 不支持拷贝或者赋值操作。
-- 向后兼容：`auto_ptr`：老版本，具有`unique_ptr`的部分特性。特别是，不能在容器中保存`auto_ptr`，也不能从函数返回`auto_ptr`。
+- 向后兼容：`auto_ptr`：老版本，具有`unique_ptr`的部分特性。特别是，不能在容器中保存`auto_ptr`，也不能从函数返回`auto_ptr`。
 
 **unique_ptr操作**:
 
 | 操作 | 解释 |
 |-----|-----|
 | `unique_ptr<T> u1` | 空`unique_ptr`，可以指向类型是`T`的对象。`u1`会使用`delete`来是释放它的指针。 |
 | `unique_ptr<T, D> u2` | `u2`会使用一个类型为`D`的可调用对象来释放它的指针。 |
-| `unique_ptr<T, D> u(d)` | 空`unique_ptr`，指向类型为`T`的对象，用类型为`D`的对象`d`代替`delete` |
+| `unique_ptr<T, D> u(d)` | 空`unique_ptr`，指向类型为`T`的对象，用类型为`D`的对象`d`代替`delete` |
 | `u = nullptr` | 释放`u`指向的对象，将`u`置为空。 |
 | `u.release()` | `u`放弃对指针的控制权，返回指针，并将`u`置空。 |
 | `u.reset()` | 释放`u`指向的对象 |
@@ -137,7 +137,7 @@
 - `delete`一个动态数组：
   - `delete [] p;`
 
-- `unique_ptr`和数组：
+- `unique_ptr`和数组：
   - 指向数组的`unique_ptr`不支持成员访问运算符（点和箭头）。
 
 | 操作 | 解释 |
@@ -148,7 +148,7 @@
 
 ### allocator类
 
-- 标准库`allocator`类定义在头文件`memory`中，帮助我们将内存分配和对象构造分离开。
+- 标准库`allocator`类定义在头文件`memory`中，帮助我们将内存分配和对象构造分离开。
 - 分配的是原始的、未构造的内存。
 - `allocator`是一个模板。
 - `allocator<string> alloc;`
@@ -158,9 +158,9 @@
 | 操作 | 解释 |
 |-----|-----|
 | `allocator<T> a` | 定义了一个名为`a`的`allocator`对象，它可以为类型为`T`的对象分配内存 |
-| `a.allocate(n)` | 分配一段原始的、未构造的内存，保存`n`个类型为`T`的对象。 |
+| `a.allocate(n)` | 分配一段原始的、未构造的内存，保存`n`个类型为`T`的对象。 |
 | `a.deallocate(p, n)` | 释放从`T*`指针`p`中地址开始的内存，这块内存保存了`n`个类型为`T`的对象；`p`必须是一个先前由`allocate`返回的指针。且`n`必须是`p`创建时所要求的大小。在调用`deallocate`之前，用户必须对每个在这块内存中创建的对象调用`destroy`。 |
-| `a.construct(p, args)` | `p`必须是一个类型是`T*`的指针，指向一块原始内存；`args`被传递给类型为`T`的构造函数，用来在`p`指向的内存中构造一个对象。 |
+| `a.construct(p, args)` | `p`必须是一个类型是`T*`的指针，指向一块原始内存；`args`被传递给类型为`T`的构造函数，用来在`p`指向的内存中构造一个对象。 |
 | `a.destroy(p)` | `p`为`T*`类型的指针，此算法对`p`指向的对象执行析构函数。 |
 
 **allocator伴随算法**：

notes/ch13.md

@@ -36,7 +36,7 @@
 
 ### 析构函数
 
-- 释放对象所使用的资源，并销毁对象的非`static`数据成员。
+- 释放对象所使用的资源，并销毁对象的非`static`数据成员。
 - 名字由波浪号接类名构成。没有返回值，也不接受参数。
 - `~Foo();`
 - 调用时机：
@@ -63,7 +63,7 @@
 
 - 大多数类应该定义默认构造函数、拷贝构造函数和拷贝赋值运算符，无论是隐式地还是显式地。
 - 定义删除的函数：`=delete`。
-- 虽然声明了它们，但是不能以任何方式使用它们。
+- 虽然声明了它们，但是不能以任何方式使用它们。
 - 析构函数不能是删除的成员。
 - 如果一个类有数据成员不能默认构造、拷贝、复制或者销毁，则对应的成员函数将被定义为删除的。
 - 老版本使用`private`声明来阻止拷贝。
@@ -98,7 +98,7 @@
 
 - `int &&rr2 = std::move(rr1);`
 - `move`告诉编译器，我们有一个左值，但我希望像右值一样处理它。
-- 调用`move`意味着：除了对`rr1`赋值或者销毁它外，我们将不再使用它。
+- 调用`move`意味着：除了对`rr1`赋值或者销毁它外，我们将不再使用它。
 
 ### 移动构造函数和移动赋值运算符
 
@@ -119,4 +119,4 @@
 
 - 区分移动和拷贝的重载函数通常有一个版本接受一个`const T&`，而另一个版本接受一个`T&&`。
 - 引用限定符：
-  - 在参数列表后面防止一个`&`，限定只能向可修改的左值赋值而不能向右值赋值。
+  - 在参数列表后面防止一个`&`，限定只能向可修改的左值赋值而不能向右值赋值。