C ++ Primer: Capítulo 9 Resumen

---

Capítulo recipiente 9 fin

9.1 Descripción general de contenedores secuencial

1. tipo de contenedor secuencial

contenedor de pedido	descripción
vector	matriz de tamaño variable
cuerda	Y el vector de tipos, sino específicamente para almacenar caracteres
y	deque
lista	lista doblemente enlazada
forward_list	lista enlazada
formación	matriz de tamaño fijo

2. Seleccionar los principios básicos de la vasija

• A menos que haya una buena razón para elegir otros recipientes, o debería utilizar vectores.
• Si el programa requiere acceso aleatorio a los elementos, el uso de vectores o deque.
• Si el programa requiere elementos craneocaudal posición de inserción o quitar sin inserción y deleción en la posición intermedia, el uso deque.
• A menos que haya una gran cantidad de pequeños elementos de un programa, y ​​los altos requisitos de espacio de arriba No usar la lista o forward_list.
• Si el programa requiere la inserción o eliminación de un elemento en el recipiente intermedio, o la lista de uso forward_list.
• Si el programa sólo cuando leo los elementos de entrada deben ser añadido en el medio del contenedor, entonces sólo al azar elementos de acceso. Para esta situación, la necesidad debe ser claro si el elemento aditivo en la posición intermedia del recipiente: para elementos añadidos centrados, tales como con el orden de clasificación de los elementos del vector puede ser reorganizado para evitar la adición del elemento en una posición intermedia por otras vías; si constante, la entrada de lectura cuando se usa después de la lista, la lista de entrada se completa la copia del vector.

Consejo: Si no está seguro de lo que para seleccionar un contenedor, se recomienda utilizar sólo el vector y una lista de operaciones comunes en el programa: el uso de un repetidor, no utilice el operador subíndice, para evitar el acceso aleatorio.

9.2 Resumen de biblioteca envase

1. Los operadores de iteradores estándar soportados

operación	descripción
* proceso	Retorno iter se hace referencia en referencia al elemento
ITER> mem	Dereference iter, y acceder a los miembros de ese elemento Mem, equivalente a (* iter) .mem
-iter1, viajando ++	Iterador hacia adelante (hacia atrás) para mover una posición forward_list no admite -
==,! =	El análisis de dos iteradores son iguales (no iguales)

2. La operación de la porción de soporte de depósito iterador (cadena, vector, deque, array)

operación	descripción
+ N viaje viaje - una	+ = Entero iterador iterador, iterador - Integer = iterador iterador se mueve hacia adelante o hacia atrás la posición de la n
N + viaje de viaje - = n	Equivalente a iter = iter + n; iter = iter - n
iter1 - iter2	Iterador - iterador = distancia tipos distancia: different_type
>,> =, <, <=	Comparación de la distancia entre dos iteradores contenedor asociativo no ordenada no es compatible

3. Los miembros de tipo de contenedor

typeAlias	descripción
iterador	Este tipo de recipiente de tipo iterador
const_iterator	Constante de tipo de iterador, no se puede modificar el elemento de Acceso
tipo de letra	Sin signo tipo entero, el contenedor suficiente para alojar todo tipo posible capacidad
diferente tipo	Firmado número entero tipo, suficiente para acomodar la distancia entre dos iteradores
tipo de valor	elementos de tipo
referencia	elementos de tipo de valor de la izquierda, lo que equivale a VALUE_TYPE y
const_refernence	elemento de tipo de valor const izquierda, equivalente a const value_type y

4. Obtener un iterador

Obtiene un iterador	descripción
c.begin (), c.end ()	El punto c, el primer elemento y el iterador elemento de la cola si c es constante, const_iterator se devuelve si c no es constante, vuelve iterador
c.cbegin (), c.cend ()	El punto c, el primer elemento y el elemento de la cola después de que el iterador devuelto const_iterator

5. contenedor inversa (forward_list no soportado)

Los miembros adicionales	descripción
reverse_iterator	Medios elementos direccionables en iterador orden inverso
const_reverse_iterator	Sólo lectura no se pueden modificar los elementos de iterador inverso
c.rbegin () c.rend ()	C iterador devuelve un puntero al último elemento antes de la primera posición, y cuando c es constante, const_reverse_iterator se devuelve si c no es constante, regreso reverse_iterator
c.rcbegin (), c.rcend ()	C iterador devuelve un puntero al último elemento antes de la primera posición y retorno const_reverse_iterator

6. definir e inicializar el contenedor

Definición e inicialización	descripción
C c	constructor predeterminado, el número de elementos está vacía si la matriz, los elementos de un número fijo de inicialización por defecto cuando el tipo de tipo de matriz elemento es una clase, la clase debe contener un constructor predeterminado
C c1 (c2) C c1 = c2	利用c2初始化c1 c1和c2容器类型和元素类型相同 若是array，还要求元素个数相同
C c{a,b,…} C c={a,b,…}	利用初始化列表来初始化c 列表元素类型与C中元素类型相容 若是array，还要求元素个数<=array大小，遗漏的元素进行值初始化
C c(b,e)	利用[b,e)内的元素初始化c 范围内元素类型与C的元素类型可转换 array不支持
C seq(n)	创建seq，并添加n个值初始化的元素 元素类型是内置类型或者具有默认构造函数的类类型 此构造函数是explicit的 string、array不支持
C seq(n,t)	创建seq，并添加n个值为t的元素 array不支持

7. 赋值和swap

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

swap	描述
swap(c1,c2) c1.swap(c2)	交换c1和c2中的元素 只交换两个容器的内部数据结构（即元素地址） 指向容器元素的原迭代器、引用和指针仍有效 若是array，真正交换元素值 若是string，指向容器元素的原迭代器、引用和指针失效

8. 容器大小操作

容器大小	描述
c.size()	c中的元素数目 forward_list不支持
c.max_size()	c可保存的最大元素数目
c.empty()	若c为空返回ture，否则返回false

9.3 顺序容器操作

1. 顺序容器访问元素

顺序容器访问元素	描述
c.front()	返回c中首元素的引用 forward_list不支持
c.beak()	返回c中尾元素的引用
c[n]	返回c中下标为n的元素的引用，0 <= n < c.size() 只支持vector、string、deque、array
c.at(n)	返回c中下标为n的元素的引用，0 <= n < c.size() 若下标越界，则抛出异常out_of_range 只支持vector、string、deque、array

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

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

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

顺序容器删除元素	描述
c.pop_front()	删除c中的首元素 返回void vector、string不支持
c.pop_back()	删除c中的尾元素 返回void forward_list不支持
c.erase§	删除迭代器p指向的元素 返回一个指向删除位置之后元素的迭代器 forward_list不支持
c.erase(b,e)	删除[b,e)内的元素 返回一个指向删除位置之后元素的迭代器 forward_list不支持
c.clear()	删除c中的所有元素 返回void

4. forward_list特有操作

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

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

改变顺序容器大小	描述
c.resize(n)	调整c的大小为n个元素
c.resize(n,t)	调整c的大小为n个元素，若n>c.size()，将多出的元素初始化为t

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

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

建议：

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

9.4 vector对象是如何增长的

1. 容器大小管理

容器大小管理	描述
c.reverse(n)	分配至少能容纳n个元素的内存空间 只支持vector、string
c.capacity()	若不重新分配内存，c可以保存的最多元素个数 只支持vector、string
c.shrink_to_fit()	将capacity()减少到size() 只支持vector、string、deque

提示：

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的构造函数

string的构造函数	描述
string s	默认构造函数，元素个数为空
string s{‘a’,‘b’,…}	将初始化列表拷贝到s
string s(n,‘a’)	s是由n个’a’组成的字符串
string s(b,e)	将[b,e)内的元素拷贝到s
string s(cp)	将cp指向的数组拷贝到s，数组必须以空字符结尾
string s(cp,n)	将从cp开始的n个字符拷贝到s
string s1(s2)	将s2拷贝到s1
string s1(s2,pos)	将s2中下标从pos开始的字符拷贝到s1
string s1(s2,pos,len)	将s2中下标从pos开始的len个字符拷贝到s1

2. string的子串操作

string的子串操作	描述
s.substr(pos,n)	返回一个string，包含s中从pos开始的n个字符的拷贝

3. string的修改操作

args形式	描述
str	字符串str：以空字符结尾的字符数组
str,pos,len	从str[pos]开始的len个字符
cp	字符数组cp
cp,len	从cp开始的len个字符
n,c	n个字符c
b,e	迭代器[b,e)内的字符
il	初始值列表。

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

4. string的搜索操作

args形式	描述
c,pos	从s[pos]开始查找c
cp,pos	从s[pos]开始查找cp
cp,pos,n	从s[pos]开始查找从cp开始的n个字符
s,pos	从s[pos]开始查找s

string的搜索操作	描述
s.find(args)	查找s中args第一次出现的位置 s.find(c,pos) s.find(cp,pos) s.find(cp,pos,n) s1.find(s2,pos)
s.rfind(args)	查找s中args最后一次出现的位置 s.rfind(c,pos) s.rfind(cp,pos) s.rfind(cp,pos,n) s1.rfind(s2,pos)
s.find_first_of(args)	在s中查找args中任何一个字符第一次出现的位置 s.find_first_of(c,pos) s.find_first_of(cp,pos) s.find_first_of(cp,pos,n) s1.find_first_of(s2,pos)
s.find_first_not_of(args)	在s中查找第一个不在args中的字符 s.find_first_not_of(c,pos) s.find_first_not_of(cp,pos) s.find_first_not_of(cp,pos,n) s1.find_first_not_of(s2,pos)
s.find_last_of(args)	在s中查找args中任何一个字符最后一次出现的位置 s.find_last_of(c,pos) s.find_last_of(cp,pos) s.find_last_of(cp,pos,n) s1.find_last_of(s2,pos)
s.find_last_not_of(args)	在s中查找最后一个不在args中的字符 s.find_last_not_of(c,pos) s.find_last_not_of(cp,pos) s.find_last_not_of(cp,pos,n) s1.find_last_not_of(s2,pos)

5. string的compare

string的compare	描述
s1.compare(s2)	比较s1和s2
s1.compare(pos1,n1,s2)	将从s1[pos1]开始的n1个字符和s2比较
s1.compare(pos1,n1,s2,pos2,n2)	将从s1[pos1]开始的n1个字符和从s2[pos2]开始的n2个字符比较
s.compare(cp)	比较s和cp
s.compare(pos,n,cp)	将从s[pos]开始的n个字符和cp比较
s.compare(pos1,n1,cp,n2)	将从s[pos1]开始的n1个字符和从cp开始的n2个字符比较

6. string的数值转换

string的数值转换	描述
to_string(val)	val -> string val：任何算术类型
stoi(s,p,b) stol(s,p,b) stoul(s,p,b) stoll(s,p,b) stoull(s,p,b)	string -> int string -> long string -> unsigned long string -> long long string -> unsigned long long p：s的下标 b：基数（8，10，16）
stof(s,p) stod(s,p) stold(s,p)	string -> float string -> double string -> long double p：s的下标

9.6 容器适配器

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

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

顺序容器适配器	要求	底层容器
stack	push_back, pop_back, back	默认deque 支持vector、list 不支持forward_list、array
queue	push_back, back, push_front, front	默认deque 支持list 不支持forward_list、array、vector
priority_queue	push_back, pop_back, front,随机访问	默认vector 支持deque 不支持forward_list、array、list

stack操作（先进后出）	描述
s.top()	返回栈顶元素
s.push(item)	将iterm压栈
s.emplace(args)	将args构造的元素压栈
s.pop()	删除栈顶元素

queue操作（先进先出）	描述
q.front()	返回queue首元素
q.back()	返回queue尾元素
q.push(item)	在queue末尾添加iterm
q.emplace(args)	在queue末尾添加由args构造的元素
q.pop()	删除queue首元素

priority_queue操作（优先级）	描述
q.top()	返回priority_queue最高优先级的元素
q.push(item)	在priority_queue合适位置添加iterm
q.emplace(args)	在priority_queue合适位置添加由args构造的元素
q.pop()	删除priority_queue最高优先级的元素

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