C++ Primer 读书笔记 Chapter 9 顺序容器

1. 顺序容器：vector（快速随机访问）； list（快速插入删除）； deque（双端队列）
2. 顺序容器适配器：stack 后进先出，栈； queue 后进先出，队列； priority_queue 优先队列；
3. 初始化
   1. C<T> C：空容器，所有容器使用
   2. C c(c2)：创建c2的副本，要求c2与C元素类型一致，所有容器使用
   3. C c(b,e)：迭代器b和e范围内的副本，所有容器使用
   4. C c(n,t)：n个t的元素创建c，只适用于顺序容器
   5. C c(n)：n个值初始化的c，只适用于顺序容器
   6. 容器的容器：vector< vector<string> >, 注意不能是vector< vector<string>>, 因为>>是右移
4. 迭代器操作：
   1. *：取值：
   2. ->：解引用，iter->mem等效于(*iter).mem
   3. ++ --
   4. == !=
   5. 以下操作只适用于vector和deque类型迭代器
      1. iter +/- n
      2. iter1 +/-= iter2
      3. iter1 – iter2
      4. <, >, <=, >=
5. 容器定义的类型别名：
   1. size_type 长度
   2. iterator, const_iterator reverse_iterator const_reverse_iterator
   3. difference_type 迭代器差值
   4. value_type 元素类型
   5. reference 元素类型的左值类型，即value_type&
   6. const_reference 常量左值，即const value_type&
6. 容器操作
   1. begin() end() rbegin() rend(): 如果容器是const，则返回const_iterator, 否则返回iterator
   2. 添加元素
      1. push_back(t)：添加值为t的副本，会复制t，所有顺序容器都支持
      2. push_front(t)：在容器c的前端添加t的副本，只适用于list和deque
      3. insert(p,t): 在迭代器p之前插入t的副本
      4. insert(p,n,t): 在迭代器p之前插入n个t的副本
      5. insert(p,b,e):在迭代器p之前插入b和e之间的元素副本
      6. 添加和删除元素都会导致容器重新加载，所有迭代器失效，避免存储end操作返回的迭代器
   3. 大小操作
      1. size() ：元素个数
      2. max_size() : 最多元素
      3. empty() 返回大小是否为0
      4. resize(n): 调整容器大小为n，如果n<原来的size，则删除多出来的，如果小于，则添加值初始化的新元素
      5. resize(n,t): 所有新添加的元素值都为t
      6. resize可能会使迭代器失效
   4. 访问操作（都返回引用）：
      1. front() back()
      2. c[n], c.at(n) 返回下标为n的引用，只适用于vector和deque
   5. 删除操作：
      1. erase(p):删除迭代器p指向的元素
      2. erase(b,e)：删除b和e之间的元素
      3. clear(): 清空所有元素
      4. pop_back()：删除最后一个元素
      5. pop_front(): 删除第一个元素，只适用于list和deque
      6. 删除操作会使迭代器失效
   6. 赋值与swap
      1. c1 = c2: 删除c1所有元素，将c2所有元素复制给c1
      2. c1.swap(c2): c1,c2交换
      3. c.assign(b,e): 重新设置c，将b和e之间的元素复制给c，b和e不能指向c中元素。
7. vector的自增长
1. capacity和reserve
2. 
3. size值是当前的大小，capacity则指必须分配新存储空间之前可以存储的元素总数。
8. 容器选用（一般vector都是最佳选择）
   1. 随机访问：vector或deque
   2. 中间插入或删除：list
   3. 首尾插入或删除：deque
   4. 在读取时在中间插入，然后需要随即访问，则可首先选用list，然后复制给一个vector
9. string
   1. 构造string的其他方法
      1. string s(cp, n) 初始化为cp的前n位副本
      2. string s(s2, pos2) 创建s2从下标pos2开始的副本
      3. stirng s(s2, pos2, len2) 同上，创建长为len2的副本
   2. 修改string的其他方法：
      1. s.insert(pos, n, c) : pos前插入n个c
      2. s.insert(pos, s2): pos前插入字符串s2
      3. s.insert(pos, s2, pos, len): pos前插入s2在pos开始的len个字符的副本
      4. s.insert(pos, cp, len): pos之前插入cp的前len个字符
      5. s.insert(pos, cp); pos之前插入cp
      6. s.assign(s2): 用s2的副本来替换s
      7. s.assign(s2, pos2, len)
      8. s.assign(cp,len)
      9. s.assign(cp)
      10. s.erase(pos, len): 删除pos开始的len个字符
      11. 上述操作都返回s的引用
   3. 只适用于string类型的操作
      1. substr
         1. substr(pos,n): 返回s在pos开始的n个字符
         2. substr(pos); 返回下标pos开始直到末尾的字符
         3. substr() 返回s副本
      2. append和replace
         1. append(args)
         2. replace(pos, len, args)
         3. replace(b, e, args)
         4. args说明：
            1. s2 字符串s2
            2. s2,pos,len 字符串s2从pos开始的len个字符
            3. cp ：char * cp
            4. cp, len": cp开始的len个字符
            5. n,c：n个c字符
            6. b2, e2： 迭代器b2到e2范围内所有字符
      3. 查找操作，返回类型为size_type
         1. find(args) rfind(args)
         2. find_first_of(args) find_last_of(args)
         3. find_first_not_of(args) find_last_not_of(args)
         4. args说明：
            1. c,pos 从pos开始找字符c
            2. s2, pos 从pos开始找字符串s2
            3. cp,pos 从pos开始找字符串cp
            4. cp,pos,n 从pos开始找字符串cp的前n个字符
            5. pos默认形参为0
         5. string上的操作区分大小写
      4. 比较操作：compare函数
         1. compare(s2) 比较s1和s2
         2. compare(pos1, n1, s2) 比较s1从pos1开始的n1个字符与s2
         3. compare(pos1, n1, s2, pos2, n2) 比较s1从pos1开始的n1个字符与s2从pos2开始的n2个字符
         4. compare(cp) 比较cp
         5. compare(pos1,n1,cp)  比较s1从pos1开始的n1个字符与cp
         6. compare(pos1,n1,cp,n2) 比较s1从pos1开始的n1个字符与cp的前n2个字符
10. 容器适配器: stack和queue都是基于deque，priority_queue基于vector
    1. 将一个顺序容器指定为适配器的第二个类型实参，可覆盖默认基础容器，e.g. stack< string, vector<string> > str_stk;
    2. 栈适配器
       1. empty()
       2. size()
       3. pop()
       4. top()
       5. push(item)
    3. 队列
       1. empty()
       2. size()
       3. pop()：删除队首
       4. front()：返回队首，不删除
       5. back()：返回队尾，不删除
       6. push(item)，队尾插入
    4. 优先队列
       1. empty()
       2. size()
       3. pop():
       4. top(): 返回最高优先级的元素
       5. push(item): 基于优先级在适当位置插入新元素