C++ Primer：第9章顺序容器

爱被打了一巴掌 2023-07-18 12:43 4阅读 0赞

--------------------

### C++Primer：第9章 顺序容器 ###

*  第9章 顺序容器
 *   *  9.1 顺序容器概述
     *   *  1. 顺序容器类型
         *  2. 选择容器的基本原则
     *  9.2 容器库概览
     *   *  1. 标准迭代器支持的运算
         *  2. 部分容器支持的迭代器运算（string、vector、deque、array）
         *  3. 容器类型成员
         *  4. 获取迭代器
         *  5. 反向容器（forward\_list不支持）
         *  6. 容器定义和初始化
         *  7. 赋值和swap
         *  8. 容器大小操作
     *  9.3 顺序容器操作
     *   *  1. 顺序容器访问元素
         *  2. 顺序容器添加元素（array不支持）
         *  3. 顺序容器删除元素（array不支持）
         *  4. forward\_list特有操作
         *  5. 改变顺序容器大小（array不支持）
         *  6. 容器操作可能使迭代器失效
     *  9.4 vector对象是如何增长的
     *   *  1. 容器大小管理
     *  9.5 额外的string操作
     *   *  1. string的构造函数
         *  2. string的子串操作
         *  3. string的修改操作
         *  4. string的搜索操作
         *  5. string的compare
         *  6. string的数值转换
     *  9.6 容器适配器

--------------------

# 第9章 顺序容器 #

## 9.1 顺序容器概述 ##

### 1. 顺序容器类型 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">顺序容器</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">vector</td> 
   <td align="left">可变大小数组</td> 
  </tr> 
  <tr> 
   <td align="left">string</td> 
   <td align="left">与vector类型，但专门用于保存字符</td> 
  </tr> 
  <tr> 
   <td align="left">deque</td> 
   <td align="left">双端队列</td> 
  </tr> 
  <tr> 
   <td align="left">list</td> 
   <td align="left">双向链表</td> 
  </tr> 
  <tr> 
   <td align="left">forward_list</td> 
   <td align="left">单向链表</td> 
  </tr> 
  <tr> 
   <td align="left">array</td> 
   <td align="left">固定大小数组</td> 
  </tr> 
 </tbody> 
</table>

### 2. 选择容器的基本原则 ###

*  除非有很好的理由选择其它容器，否则应使用vector。
 *  若程序要求随机访问元素，应使用vector或deque。
 *  若程序要求在头尾位置插入或删除元素，不会在中间位置进行插入和删除，应使用deque。
 *  除非程序中有很多的小元素，且对空间额外开销要求高，否则不要使用list或forward\_list。
 *  若程序要求在容器中间插入或删除元素，应使用list或forward\_list。
 *  若程序只有在读取输入时才需要在容器中间位置添加元素，之后只需随机访问元素。针对这种情况，需明确是否一定要在容器中间位置添加元素：通过其它途径实现居中添加元素，如对vector使用sort重排元素顺序可避免在中间位置添加元素；若一定，则在读取输入时用list，输入完成后将list拷贝到vector。

提示：若不确定选择哪个容器，建议在程序中只使用vector和list的公共操作：使用迭代器，不使用下标操作，避免随机访问。

## 9.2 容器库概览 ##

### 1. 标准迭代器支持的运算 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">运算</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">*iter</td> 
   <td align="left">返回iter所指元素的引用</td> 
  </tr> 
  <tr> 
   <td align="left">iter-&gt;mem</td> 
   <td align="left">解引用iter，并访问该元素的成员mem，等价于(*iter).mem</td> 
  </tr> 
  <tr> 
   <td align="left">–iter1，++iter</td> 
   <td align="left">迭代器向前（向后）移动一个位置<br><strong>forward_list不支持–</strong></td> 
  </tr> 
  <tr> 
   <td align="left">==、!=</td> 
   <td align="left">判断两个迭代器是否相等（不相等）</td> 
  </tr> 
 </tbody> 
</table>

### 2. 部分容器支持的迭代器运算（string、vector、deque、array） ###

<table> 
 <thead> 
  <tr> 
   <th align="left">运算</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">iter + n<br>iter - n</td> 
   <td align="left">迭代器+整型=迭代器，迭代器-整型=迭代器<br>迭代器向前或向后移动n个位置</td> 
  </tr> 
  <tr> 
   <td align="left">iter += n<br>iter -= n</td> 
   <td align="left">等价于iter = iter + n; iter = iter - n</td> 
  </tr> 
  <tr> 
   <td align="left">iter1 - iter2</td> 
   <td align="left">迭代器-迭代器=距离<br>距离的类型：different_type</td> 
  </tr> 
  <tr> 
   <td align="left">&gt;、&gt;=、&lt;、&lt;=</td> 
   <td align="left">比较两个迭代器之间的距离<br><strong>无序关联容器不支持</strong></td> 
  </tr> 
 </tbody> 
</table>

### 3. 容器类型成员 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">类型别名</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">iterator</td> 
   <td align="left">此容器类型的迭代器类型</td> 
  </tr> 
  <tr> 
   <td align="left">const_iterator</td> 
   <td align="left">常量迭代器类型，可访问不可修改元素</td> 
  </tr> 
  <tr> 
   <td align="left">size_type</td> 
   <td align="left">无符号整数类型，足够容纳该容器类型所有可能的容量</td> 
  </tr> 
  <tr> 
   <td align="left">different_type</td> 
   <td align="left">带符号整数类型，足够容纳两个迭代器之间的距离</td> 
  </tr> 
  <tr> 
   <td align="left">value_type</td> 
   <td align="left">元素的类型</td> 
  </tr> 
  <tr> 
   <td align="left">reference</td> 
   <td align="left">元素的左值类型，等价于value_type &amp;</td> 
  </tr> 
  <tr> 
   <td align="left">const_refernence</td> 
   <td align="left">元素的const左值类型，等价于const value_type &amp;</td> 
  </tr> 
 </tbody> 
</table>

### 4. 获取迭代器 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">获取迭代器</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">c.begin()、c.end()</td> 
   <td align="left">指向c中首元素和尾后元素的迭代器<br><strong>若c是const，则返回const_iterator</strong><br><strong>若c不是const，则返回iterator</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.cbegin()、c.cend()</td> 
   <td align="left">指向c中首元素和尾后元素的迭代器<br>返回const_iterator</td> 
  </tr> 
 </tbody> 
</table>

### 5. 反向容器（forward\_list不支持） ###

<table> 
 <thead> 
  <tr> 
   <th align="left">额外成员</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">reverse_iterator</td> 
   <td align="left">指按逆序寻址元素的迭代器</td> 
  </tr> 
  <tr> 
   <td align="left">const_reverse_iterator</td> 
   <td align="left">只能读取不能修改元素的逆序迭代器</td> 
  </tr> 
  <tr> 
   <td align="left">c.rbegin()、c.rend()</td> 
   <td align="left">返回指向c的尾元素和首前位置的迭代器<br><strong>若c是const，则返回const_reverse_iterator</strong><br><strong>若c不是const，则返回reverse_iterator</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.rcbegin()、c.rcend()</td> 
   <td align="left">返回指向c的尾元素和首前位置的迭代器<br>返回const_reverse_iterator</td> 
  </tr> 
 </tbody> 
</table>

### 6. 容器定义和初始化 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">定义与初始化</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">C c</td> 
   <td align="left">默认构造函数，元素个数为空<br><strong>若是array，则固定个数的元素默认初始化<br>若array元素类型是类类型，则该类必须含有默认构造函数</strong></td> 
  </tr> 
  <tr> 
   <td align="left">C c1(c2)<br>C c1=c2</td> 
   <td align="left">利用c2初始化c1<br>c1和c2容器类型和元素类型相同<br><strong>若是array，还要求元素个数相同</strong></td> 
  </tr> 
  <tr> 
   <td align="left">C c{a,b,…}<br>C c={a,b,…}</td> 
   <td align="left">利用初始化列表来初始化c<br>列表元素类型与C中元素类型相容<br><strong>若是array，还要求元素个数&lt;=array大小，遗漏的元素进行值初始化</strong></td> 
  </tr> 
  <tr> 
   <td align="left">C c(b,e)</td> 
   <td align="left">利用[b,e)内的元素初始化c<br>范围内元素类型与C的元素类型可转换<br><strong>array不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">C seq(n)</td> 
   <td align="left">创建seq，并添加n个值初始化的元素<br>元素类型是内置类型或者具有默认构造函数的类类型<br>此构造函数是explicit的<br><strong>string、array不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">C seq(n,t)</td> 
   <td align="left">创建seq，并添加n个值为t的元素<br><strong>array不支持</strong></td> 
  </tr> 
 </tbody> 
</table>

### 7. 赋值和swap ###

<table> 
 <thead> 
  <tr> 
   <th align="left">赋值</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">c1=c2</td> 
   <td align="left">将c2元素拷贝到c1<br>c1和c2容器类型和元素类型相同<br><strong>若是array，还要求元素个数相同</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c={a,b,…}</td> 
   <td align="left">将初始化列表中的元素拷贝到c<br>列表元素类型与C中元素类型相容<br><strong>若是array，还要求元素个数&lt;=array大小，遗漏的元素进行值初始化</strong></td> 
  </tr> 
  <tr> 
   <td align="left">seq.assign(il)</td> 
   <td align="left">将初始化列表il拷贝到seq<br><strong>关联容器、array不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">seq.assign(b,e)</td> 
   <td align="left">将[b,e)内的元素拷贝到seq<br>范围内元素类型与seq的元素类型可转换<br><strong>关联容器、array不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">seq.assign(n,t)</td> 
   <td align="left">将n个值为t的元素拷贝到seq<br><strong>关联容器、array不支持</strong></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left">swap</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">swap(c1,c2)<br>c1.swap(c2)</td> 
   <td align="left">交换c1和c2中的元素<br>只交换两个容器的内部数据结构（即元素地址）<br>指向容器元素的原迭代器、引用和指针仍有效<br><strong>若是array，真正交换元素值</strong><br><strong>若是string，指向容器元素的原迭代器、引用和指针失效</strong></td> 
  </tr> 
 </tbody> 
</table>

### 8. 容器大小操作 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">容器大小</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">c.size()</td> 
   <td align="left">c中的元素数目<br><strong>forward_list不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.max_size()</td> 
   <td align="left">c可保存的最大元素数目</td> 
  </tr> 
  <tr> 
   <td align="left">c.empty()</td> 
   <td align="left">若c为空返回ture，否则返回false</td> 
  </tr> 
 </tbody> 
</table>

## 9.3 顺序容器操作 ##

### 1. 顺序容器访问元素 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">顺序容器访问元素</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">c.front()</td> 
   <td align="left">返回c中首元素的引用<br><strong>forward_list不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.beak()</td> 
   <td align="left">返回c中尾元素的引用</td> 
  </tr> 
  <tr> 
   <td align="left">c[n]</td> 
   <td align="left">返回c中下标为n的元素的引用，0 &lt;= n &lt; c.size()<br><strong>只支持vector、string、deque、array</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.at(n)</td> 
   <td align="left">返回c中下标为n的元素的引用，0 &lt;= n &lt; c.size()<br>若下标越界，则抛出异常out_of_range<br><strong>只支持vector、string、deque、array</strong></td> 
  </tr> 
 </tbody> 
</table>

### 2. 顺序容器添加元素（array不支持） ###

<table> 
 <thead> 
  <tr> 
   <th align="left">顺序容器添加元素</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">c.push_front(t)</td> 
   <td align="left">在c的首部创建一个值为t的元素<br>返回void<br><strong>vector、string不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.emplace_front(args)</td> 
   <td align="left">在c的首部创建一个由args创建的元素<br>返回void<br><strong>vector、string不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.push_back(t)</td> 
   <td align="left">在c的尾部创建一个值为t的元素<br>返回void<br><strong>forward_list不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.emplace_back(args)</td> 
   <td align="left">在c的尾部创建一个由args创建的元素<br>返回void<br><strong>forward_list不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.insert(p,t)</td> 
   <td align="left">在迭代器p之前创建一个值为t的元素<br>返回指向新添加的元素的迭代器<br><strong>forward_list不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.emplace(p,args)</td> 
   <td align="left">在迭代器p之前创建一个由args创建的元素<br>返回指向新添加的元素的迭代器<br><strong>forward_list不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.insert(p,n,t)</td> 
   <td align="left">在迭代器p之前创建n个值为t的元素<br>返回指向新添加的第一个元素的迭代器<br><strong>forward_list不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.insert(p,b,e)</td> 
   <td align="left">在迭代器p之前插入[b,e)内的元素<br>返回指向新添加的第一个元素的迭代器<br><strong>forward_list不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.insert(p,il)</td> 
   <td align="left">在迭代器p之前插入初始值列表il中的元素<br>返回指向新添加的第一个元素的迭代器<br><strong>forward_list不支持</strong></td> 
  </tr> 
 </tbody> 
</table>

### 3. 顺序容器删除元素（array不支持） ###

<table> 
 <thead> 
  <tr> 
   <th align="left">顺序容器删除元素</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">c.pop_front()</td> 
   <td align="left">删除c中的首元素<br>返回void<br><strong>vector、string不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.pop_back()</td> 
   <td align="left">删除c中的尾元素<br>返回void<br><strong>forward_list不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.erase§</td> 
   <td align="left">删除迭代器p指向的元素<br>返回一个指向删除位置之后元素的迭代器<br><strong>forward_list不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.erase(b,e)</td> 
   <td align="left">删除[b,e)内的元素<br>返回一个指向删除位置之后元素的迭代器<br><strong>forward_list不支持</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.clear()</td> 
   <td align="left">删除c中的所有元素<br>返回void</td> 
  </tr> 
 </tbody> 
</table>

### 4. forward\_list特有操作 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">forward_list特有操作</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">lst.before_begin()</td> 
   <td align="left">返回指向首前元素的迭代器iterator</td> 
  </tr> 
  <tr> 
   <td align="left">lst.cbefore_begin()</td> 
   <td align="left">返回指向首前元素的迭代器const_iterator</td> 
  </tr> 
  <tr> 
   <td align="left">lst.emplace_after(p,args)</td> 
   <td align="left">在迭代器p之后插入1个由args构造的元素<br>返回指向插入元素的迭代器</td> 
  </tr> 
  <tr> 
   <td align="left">lst.insert_after(p,t)</td> 
   <td align="left">在迭代器p之后插入1个值为t的元素<br>返回指向插入元素的迭代器</td> 
  </tr> 
  <tr> 
   <td align="left">lst.insert_after(p,n,t)</td> 
   <td align="left">在迭代器p之后插入n个值为t的元素<br>返回指向最后一个插入元素的迭代器</td> 
  </tr> 
  <tr> 
   <td align="left">lst.insert_after(p,b,e)</td> 
   <td align="left">在迭代器p之后插入[b,e)内的元素<br>返回指向最后一个插入元素的迭代器</td> 
  </tr> 
  <tr> 
   <td align="left">lst.insert_after(p,il)</td> 
   <td align="left">在迭代器p之后插入初始值列表中的元素<br>返回指向最后一个插入元素的迭代器</td> 
  </tr> 
  <tr> 
   <td align="left">lst.erase_after§</td> 
   <td align="left">删除迭代器p之后的一个元素<br>返回一个指向删除位置之后元素的迭代器</td> 
  </tr> 
  <tr> 
   <td align="left">lst.erase_after(b,e)</td> 
   <td align="left">删除(b,e]的元素<br>返回一个指向删除位置之后元素的迭代器</td> 
  </tr> 
 </tbody> 
</table>

### 5. 改变顺序容器大小（array不支持） ###

<table> 
 <thead> 
  <tr> 
   <th align="left">改变顺序容器大小</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">c.resize(n)</td> 
   <td align="left">调整c的大小为n个元素</td> 
  </tr> 
  <tr> 
   <td align="left">c.resize(n,t)</td> 
   <td align="left">调整c的大小为n个元素，若n&gt;c.size()，将多出的元素初始化为t</td> 
  </tr> 
 </tbody> 
</table>

### 6. 容器操作可能使迭代器失效 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">容器操作</th> 
   <th align="left">失效情况</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">vector<br>string</td> 
   <td align="left">添加元素：若重新分配内存，所有迭代器、指针和引用都失效<br>     若未重新分配内存，插入位置之后迭代器、指针和引用都失效<br>删除元素：指向被删元素及其后元素的迭代器、引用和指针失效</td> 
  </tr> 
  <tr> 
   <td align="left">deque</td> 
   <td align="left">添加元素：若插在首尾位置，所有迭代器失效，但引用和指针有效<br>     若插在首尾位置之外，所有迭代器、指针和引用都失效<br>删除元素：若删除首尾元素，尾后迭代器失效，但其余迭代器、引用和指针仍有效<br>     若删除首尾之外的元素，所有迭代器、指针和引用都失效</td> 
  </tr> 
  <tr> 
   <td align="left">list<br>forward_list</td> 
   <td align="left">添加元素：所有迭代器、引用和指针仍有效<br>删除元素：指向被删元素的迭代器、指针和引用都失效</td> 
  </tr> 
  <tr> 
   <td align="left">array</td> 
   <td align="left">添加元素：不能插入<br>删除元素：不能删除</td> 
  </tr> 
 </tbody> 
</table>

建议：

1.  在vector、string和deque中添加或删除元素，必须考虑指向容器元素的迭代器、引用和指针失效的问题。在循环中，尽量使用insert或erase更新迭代器。
2.  在vector、string中添加或删除元素，或者在deque首元素之外添加或删除元素总会使尾后迭代器end()失效。故此时不要保存end()返回的迭代器。

## 9.4 vector对象是如何增长的 ##

### 1. 容器大小管理 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">容器大小管理</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">c.reverse(n)</td> 
   <td align="left">分配至少能容纳n个元素的内存空间<br><strong>只支持vector、string</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.capacity()</td> 
   <td align="left">若不重新分配内存，c可以保存的最多元素个数<br><strong>只支持vector、string</strong></td> 
  </tr> 
  <tr> 
   <td align="left">c.shrink_to_fit()</td> 
   <td align="left">将capacity()减少到size()<br><strong>只支持vector、string、deque</strong></td> 
  </tr> 
 </tbody> 
</table>

提示：

1.  c.size()输出元素个数，c.max\_size()输出可保存的最大元素个数，c.resize()改变元素个数，c.reverse()输出不重新分配内存情况下可保存的元素个数。
2.  只有当n>c.capacity()时，c.resize(n)和c.reserve(n)才会改变c的容量；只有当n==c.capacity()时，再添加元素才会改变c的容量。

## 9.5 额外的string操作 ##

### 1. string的构造函数 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">string的构造函数</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">string s</td> 
   <td align="left">默认构造函数，元素个数为空</td> 
  </tr> 
  <tr> 
   <td align="left">string s(n,‘a’)</td> 
   <td align="left">s是由n个’a’组成的字符串</td> 
  </tr> 
  <tr> 
   <td align="left">string s{‘a’,‘b’,…}</td> 
   <td align="left">将初始化列表拷贝到s</td> 
  </tr> 
  <tr> 
   <td align="left">string s(cp)<br>string s(cp,n)</td> 
   <td align="left">将cp指向的数组拷贝到s，数组必须以空字符结尾<br>将从cp开始的n个字符拷贝到s</td> 
  </tr> 
  <tr> 
   <td align="left">string s1(s2)<br>string s1(s2,pos)<br>string s1(s2,pos,len)<br>string s(b,e)</td> 
   <td align="left">将s2拷贝到s1<br>将s2中下标从pos开始的字符拷贝到s1<br>将s2中下标从pos开始的len个字符拷贝到s1<br>将迭代器[b,e)内的元素拷贝到s</td> 
  </tr> 
 </tbody> 
</table>

### 2. string的子串操作 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">string的子串操作</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">s.substr(pos,n)</td> 
   <td align="left">返回一个string，包含s中从pos开始的n个字符的拷贝</td> 
  </tr> 
 </tbody> 
</table>

### 3. string的修改操作 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">args形式</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">str</td> 
   <td align="left">字符串str：以空字符结尾的字符数组</td> 
  </tr> 
  <tr> 
   <td align="left">str,pos,len</td> 
   <td align="left">从str[pos]开始的len个字符</td> 
  </tr> 
  <tr> 
   <td align="left">cp</td> 
   <td align="left">字符数组cp</td> 
  </tr> 
  <tr> 
   <td align="left">cp,len</td> 
   <td align="left">从cp开始的len个字符</td> 
  </tr> 
  <tr> 
   <td align="left">n,c</td> 
   <td align="left">n个字符c</td> 
  </tr> 
  <tr> 
   <td align="left">b,e</td> 
   <td align="left">迭代器[b,e)内的字符</td> 
  </tr> 
  <tr> 
   <td align="left">il</td> 
   <td align="left">初始值列表。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left">string的修改操作</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">s.insert(p,args)</td> 
   <td align="left">在迭代器p之前插入args指定的字符，返回指向第一插入字符的迭代器<br>s.insert(p,n,c)<br>s.insert(p,b,e)<br>s.insert(p,il)</td> 
  </tr> 
  <tr> 
   <td align="left">s.insert(pos,args)</td> 
   <td align="left">在s[pos]之前插入args指定的字符，返回一个指向s的引用<br>s.insert(pos,str)<br>s.insert(pos,str,pos,len)<br>s.insert(pos,cp,len)<br>s.insert(pos,n,c)</td> 
  </tr> 
  <tr> 
   <td align="left">s.erase(pos)<br>s.erase(pos,n)</td> 
   <td align="left">删除从s[pos]开始到末尾的字符，返回一个指向s的引用<br>删除从s[pos]开始的n个字符，返回一个指向s的引用</td> 
  </tr> 
  <tr> 
   <td align="left">s.assign(args)</td> 
   <td align="left">用args指定的字符替换s中的字符，返回一个指向s的引用<br>s.assign(str)<br>s.assign(str,pos,len)<br>s.assign(cp)<br>s.assign(cp,len)<br>s.assign(n,c)<br>s.assign(b,e)<br>s.assign(il)</td> 
  </tr> 
  <tr> 
   <td align="left">s.append(args)</td> 
   <td align="left">将args追加到s，返回一个指向s的引用<br>s.append(str)<br>s.append(str,pos,len)<br>s.append(cp)<br>s.append(cp,len)<br>s.append(n,c)<br>s.append(b,e)<br>s.append(il)</td> 
  </tr> 
  <tr> 
   <td align="left">s.replace(b,e,args)</td> 
   <td align="left">将[b,e)内的字符替换为args指定的字符，返回一个指向s的引用<br>s.replace(b,e,str)<br>s.replace(b,e,str,pos,len)——错误<br>s.replace(b,e,cp)<br>s.replace(b,e,cp,len)<br>s.replace(b,e,n,c)<br>s.replace(b1,e1,b2,e2)<br>s.replace(b,e,il)</td> 
  </tr> 
  <tr> 
   <td align="left">s.replace(pos,n,args)</td> 
   <td align="left">将从s[pos]开始的n个字符替换为args指定的字符，返回一个指向s的引用<br>s.replace(pos,n,str)<br>s.replace(pos,n,str,pos,len)<br>s.replace(pos,n,cp)<br>s.replace(pos,n,cp,len)<br>s.replace(pos,n1,n2,c)<br>s.replace(pos,n,b,e)——错误<br>s.replace(pos,n,il)——错误</td> 
  </tr> 
 </tbody> 
</table>

### 4. string的搜索操作 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">args形式</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">c,pos</td> 
   <td align="left">从s[pos]开始查找c</td> 
  </tr> 
  <tr> 
   <td align="left">cp,pos</td> 
   <td align="left">从s[pos]开始查找cp</td> 
  </tr> 
  <tr> 
   <td align="left">cp,pos,n</td> 
   <td align="left">从s[pos]开始查找从cp开始的n个字符</td> 
  </tr> 
  <tr> 
   <td align="left">s,pos</td> 
   <td align="left">从s[pos]开始查找s</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left">string的搜索操作</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">s.find(args)</td> 
   <td align="left">查找s中args第一次出现的位置<br>s.find(c,pos)<br>s.find(cp,pos)<br>s.find(cp,pos,n)<br>s1.find(s2,pos)</td> 
  </tr> 
  <tr> 
   <td align="left">s.rfind(args)</td> 
   <td align="left">查找s中args最后一次出现的位置<br>s.rfind(c,pos)<br>s.rfind(cp,pos)<br>s.rfind(cp,pos,n)<br>s1.rfind(s2,pos)</td> 
  </tr> 
  <tr> 
   <td align="left">s.find_first_of(args)</td> 
   <td align="left">在s中查找args中任何一个字符第一次出现的位置<br>s.find_first_of(c,pos)<br>s.find_first_of(cp,pos)<br>s.find_first_of(cp,pos,n)<br>s1.find_first_of(s2,pos)</td> 
  </tr> 
  <tr> 
   <td align="left">s.find_first_not_of(args)</td> 
   <td align="left">在s中查找第一个不在args中的字符<br>s.find_first_not_of(c,pos)<br>s.find_first_not_of(cp,pos)<br>s.find_first_not_of(cp,pos,n)<br>s1.find_first_not_of(s2,pos)</td> 
  </tr> 
  <tr> 
   <td align="left">s.find_last_of(args)</td> 
   <td align="left">在s中查找args中任何一个字符最后一次出现的位置<br>s.find_last_of(c,pos)<br>s.find_last_of(cp,pos)<br>s.find_last_of(cp,pos,n)<br>s1.find_last_of(s2,pos)</td> 
  </tr> 
  <tr> 
   <td align="left">s.find_last_not_of(args)</td> 
   <td align="left">在s中查找最后一个不在args中的字符<br>s.find_last_not_of(c,pos)<br>s.find_last_not_of(cp,pos)<br>s.find_last_not_of(cp,pos,n)<br>s1.find_last_not_of(s2,pos)</td> 
  </tr> 
 </tbody> 
</table>

提示：编译结果因不同C++标准而不同。

### 5. string的compare ###

<table> 
 <thead> 
  <tr> 
   <th align="left">string的compare</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">s1.compare(s2)</td> 
   <td align="left">比较s1和s2</td> 
  </tr> 
  <tr> 
   <td align="left">s1.compare(pos1,n1,s2)</td> 
   <td align="left">将从s1[pos1]开始的n1个字符和s2比较</td> 
  </tr> 
  <tr> 
   <td align="left">s1.compare(pos1,n1,s2,pos2,n2)</td> 
   <td align="left">将从s1[pos1]开始的n1个字符和从s2[pos2]开始的n2个字符比较</td> 
  </tr> 
  <tr> 
   <td align="left">s.compare(cp)</td> 
   <td align="left">比较s和cp</td> 
  </tr> 
  <tr> 
   <td align="left">s.compare(pos,n,cp)</td> 
   <td align="left">将从s[pos]开始的n个字符和cp比较</td> 
  </tr> 
  <tr> 
   <td align="left">s.compare(pos1,n1,cp,n2)</td> 
   <td align="left">将从s[pos1]开始的n1个字符和从cp开始的n2个字符比较</td> 
  </tr> 
 </tbody> 
</table>

### 6. string的数值转换 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">string的数值转换</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">to_string(val)</td> 
   <td align="left">val -&gt; string<br>val：任何算术类型</td> 
  </tr> 
  <tr> 
   <td align="left">stoi(s,p,b)<br>stol(s,p,b)<br>stoul(s,p,b)<br>stoll(s,p,b)<br>stoull(s,p,b)</td> 
   <td align="left">string -&gt; int<br>string -&gt; long<br>string -&gt; unsigned long<br>string -&gt; long long<br>string -&gt; unsigned long long<br>p：s的下标<br>b：基数（8，10，16）</td> 
  </tr> 
  <tr> 
   <td align="left">stof(s,p)<br>stod(s,p)<br>stold(s,p)</td> 
   <td align="left">string -&gt; float<br>string -&gt; double<br>string -&gt; long double<br>p：s的下标</td> 
  </tr> 
 </tbody> 
</table>

## 9.6 容器适配器 ##

适配器：一种机制，能使某种事物的行为看起来像另一种事物一样。  
容器适配器：一个容器适配器接受一种已有的容器类型，其行为看起来像另一种类型。

<table> 
 <thead> 
  <tr> 
   <th align="left">适配器支持的操作</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">size_type</td> 
   <td align="left">一种类型，足以保存当前类型最大对象的大小</td> 
  </tr> 
  <tr> 
   <td align="left">value_type</td> 
   <td align="left">元素类型</td> 
  </tr> 
  <tr> 
   <td align="left">container_type</td> 
   <td align="left">实现适配器的底层容器类型</td> 
  </tr> 
  <tr> 
   <td align="left">A a;</td> 
   <td align="left">创建一个名为a的空适配器</td> 
  </tr> 
  <tr> 
   <td align="left">A a©;</td> 
   <td align="left">创建一个名为a的适配器，拷贝容器c的元素</td> 
  </tr> 
  <tr> 
   <td align="left">==, !=, &lt;, &lt;=, &gt;, &gt;=</td> 
   <td align="left">返回底层容器的比较结果</td> 
  </tr> 
  <tr> 
   <td align="left">a.empty()</td> 
   <td align="left">若适配器为空，返回true，否则返回false</td> 
  </tr> 
  <tr> 
   <td align="left">a.size()</td> 
   <td align="left">返回a的元素个数</td> 
  </tr> 
  <tr> 
   <td align="left">swap(a,b)<br>a.swap(b)</td> 
   <td align="left">交换a和b的内容<br>要求：a和b是同一类型，底层容器也是同一类型</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left">顺序容器适配器</th> 
   <th align="left">要求</th> 
   <th align="left">底层容器</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">stack</td> 
   <td align="left">push_back, pop_back, back</td> 
   <td align="left">默认deque<br>支持vector、list<br>不支持forward_list、array</td> 
  </tr> 
  <tr> 
   <td align="left">queue</td> 
   <td align="left">push_back, back, push_front, front</td> 
   <td align="left">默认deque<br>支持list<br>不支持forward_list、array、vector</td> 
  </tr> 
  <tr> 
   <td align="left">priority_queue</td> 
   <td align="left">push_back, pop_back, front,随机访问</td> 
   <td align="left">默认vector<br>支持deque<br>不支持forward_list、array、list</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left">stack操作（先进后出）</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">s.top()</td> 
   <td align="left">返回栈顶元素</td> 
  </tr> 
  <tr> 
   <td align="left">s.push(item)</td> 
   <td align="left">将iterm压栈</td> 
  </tr> 
  <tr> 
   <td align="left">s.emplace(args)</td> 
   <td align="left">将args构造的元素压栈</td> 
  </tr> 
  <tr> 
   <td align="left">s.pop()</td> 
   <td align="left">删除栈顶元素</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left">queue操作（先进先出）</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">q.front()</td> 
   <td align="left">返回queue首元素</td> 
  </tr> 
  <tr> 
   <td align="left">q.back()</td> 
   <td align="left">返回queue尾元素</td> 
  </tr> 
  <tr> 
   <td align="left">q.push(item)</td> 
   <td align="left">在queue末尾添加iterm</td> 
  </tr> 
  <tr> 
   <td align="left">q.emplace(args)</td> 
   <td align="left">在queue末尾添加由args构造的元素</td> 
  </tr> 
  <tr> 
   <td align="left">q.pop()</td> 
   <td align="left">删除queue首元素</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left">priority_queue操作（优先级）</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">q.top()</td> 
   <td align="left">返回priority_queue最高优先级的元素</td> 
  </tr> 
  <tr> 
   <td align="left">q.push(item)</td> 
   <td align="left">在priority_queue合适位置添加iterm</td> 
  </tr> 
  <tr> 
   <td align="left">q.emplace(args)</td> 
   <td align="left">在priority_queue合适位置添加由args构造的元素</td> 
  </tr> 
  <tr> 
   <td align="left">q.pop()</td> 
   <td align="left">删除priority_queue最高优先级的元素</td> 
  </tr> 
 </tbody> 
</table>

提示：容器适配器只能使用自己的操作，而不能使用底层容器的操作。