C++ Primer学习笔记2--c++顺序容器

顺序容器

vector    支持快速随机访问

 

list      支持快速插入/删除

 

deque      双端队列

 

顺序容器适配器

 stack后进先出(LIFO)堆栈

 

 queue先进先出(FIFO)队列

 

 priority_queue有优先级管理的队列

 

 

 为了定义 一个容器类型的对象,必须先包含相关的头文件,即下列头文件之一:

 #include <vector>

 #include <list>

 #include <deque>

 

 所有的容器都是类模板。要定义某种特殊的容器,必须在容 器名后加一对尖括号,尖括号里面提供容器中存放的元素的类型:

 vector<string> svec; 

 list<int> ilist; 

 deque<Sales_item> items;

  

 容器的构造函数（以vector为例）

 1.默认构造函数   vector<string> svec;  

 2.将一个容器初始化为另一个容器的副本 vector<string> ivec2(svec); //容器类型元素类型必须相同

 3.初始化为一段元素的副本(传递2个迭代器为参数，标记开始结束,不要求容器 类型相同。容器内的元素类型也可以不相同,只要它们相互兼容,能够将要复制 的元素转换为所构建的新容器的元素类型,即可实现复制。)

 

 list<string> slist(svec.begin(), svec.end());

 

 vector<string>::iterator mid = svec.begin() + svec.size()/2;

 

 deque<string> front(svec.begin(), mid);

 deque<string> back(mid, svec.end());

 

 通过使用内置数组中的一对指针初始化容器

 char *words[] = {"stately", "plump", "buck", "mulligan"};

 

 size_t words_size = sizeof(words)/sizeof(char *);

 list<string> words2(words, words + words_size);//通过指向第一 个元素的指针 words 和指向数组中最后一个元素的下一位置的指针,实现了 words2 的初始化。其中第二个指针提供停止复制的条件,其所指向的位置上存 放的元素并没有复制。

 

 4.分配和初始化指定数目的元素（=顺序容器=）

  const list<int>::size_type list_size = 64;

  list<string> slist(list_size, "eh?");64个eh?

  list<int> ilist(list_size);64个0  采用这种类型的初始化,元素类型必须是内置或复合类型,或者是提供了默认构 造函数的类类型。如果元素类型没有默认构造函数,则必须显式指定其元素初始 化式。

 

 • 元素类型必须支持赋值运算。

 • 元素类型的对象必须可以复制。

 IO标准库类型和引用类型不能作为容器元素类型

 

 

 

 迭代器

 

 常用迭代器运算

 

 *iter       返回迭代器 iter 所指向的元素的引用

 

 iter->mem   对 iter 进行解引用,获取指定元素中名为 mem 的成员。等效于 (*iter).mem

 

 *iter       返回迭代器 iter 所指向的元素的引用

 

 ++iter   iter++给 iter 加 1,使其指向容器里的下一个元素

 --iter   iter-- 给 iter 减 1,使其指向容器里的前一个元素

 

 iter1 ==iter2

 iter1 !=iter2

 比较两个迭代器是否相等(或不等)。当两个迭代器指向同一个

 容器中的同一个元素,或者当它们都指向同一个容器的超出末端

 的下一位置时,两个迭代器相等

 

 

 vector  deque专有操作

 iter+n iter-n

 在迭代器上加(减)整数值 n,将产生指向容器中前面(后面)第 n 个元素的迭代器。新计算出来的迭代器必须指向容器中的元素或超出 容器末端的下一位置

 

 iter1 += iter2 iter1 -= iter2 

 这里迭代器加减法的复合赋值运算:将 iter1 加上或减去 iter2 的 运算结果赋给 iter1

 

 iter1 - iter2

 两个迭代器的减法,其运算结果加上右边的迭代器即得左边的迭代 器。这两个迭代器必须指向同一个容器中的元素或超出容器末端的下 一位置

 只适用于 vector 和 deque 容器

 

 

 >, >=, <, <=

 迭代器的关系操作符。当一个迭代器指向的元素在容器中位于另一个 迭代器指向的元素之前,则前一个迭代器小于后一个迭代器。关系操 作符的两个迭代器必须指向同一个容器中的元素或超出容器末端的 下一位置

 

 list 容器的迭代器既不支持算术运算(加法或减法),也不支 持关系运算(<=, <, >=, >),它只提供前置和后置的自增、自减运算以及相等 (不等)运算。

 

 

 容器定义的类型别名：

 

 size_type 无符号整型,足以存储此容器类型的最大可能容器长 度

 iterator 此容器类型的迭代器类型

 const_iterator  元素的只读迭代器类型

 reverse_iterator 按逆序寻址元素的迭代器

 const_reverse_iterator 元素的只读(不能写)逆序迭代器

difference_type 足够存储两个迭代器差值的有符号整型,可为负数

value_type 元素类型

reference 元素的左值类型,是 value_type& 的同义词

 const_reference 元素的常量左值类型,等效于 const value_type&

 

 使用类型别名定义变量

 list<string>::iterator iter;

 

 vector<int>::difference_type cnt;

 

 

 c.begin()

返回一个迭代器,它指向容器 c 的第一个元素

 

 c.end()

 返回一个迭代器,它指向容器 c 的最后一个元素的下一位置

 

 c.rbegin()

 返回一个逆序迭代器,它指向容器 c 的最后一个元素

 

 c.rend()

 返回一个逆序迭代器,它指向容器 c 的第一个元素前面的位置

 

 添加元素

 除了 push_back 运算,list 和 deque 容器类型还提供了类似的操作: push_front。

 

 

 在顺序容器中添加元素的操作

 c.push_back(t)

 在容器 c 的尾部添加值为 t 的元素。返回 void 类型

 

 c.push_front(t)

 在容器 c 的前端添加值为 t 的元素。返回 void 类型 只适用于 list 和 deque 容器类型.

 

 c.insert(p,t)

 在迭代器 p 所指向的元素前面插入值为 t 的新元素。返回 指向新添加元素的迭代器

 

 

 c.insert(p,n,t)

 在迭代器 p 所指向的元素前面插入 n 个值为 t 的新元素。 返回 void 类型

 

 

 c.insert(p,b,e)

 在迭代器 p 所指向的元素前面插入由迭代器 b 和 e 标记 的范围内的元素。返回 void 类型

 

 

 

 顺序容器大小操作

 c.size()

 

 返回容器 c 中的元素个数。返回类型为 c::size_type

 

 c.max_size()

 

 返回容器 c 可容纳的最多元素个数,返回类型为 c::size_type

 

 

 c.empty()

 

 返回标记容器大小是否为 0 的布尔值

 

 c.resize(n)

 调整容器 c 的长度大小,使其能容纳 n 个元素,如果 n < c.size(),则删除多出来的元素;否则,添加采用值初始化的 新元素

 

 

 c.resize(n,t)

 

 调整容器 c 的长度大小,使其能容纳 n 个元素。所有新添加 的元素值都为 t

 

 

 

----访问顺序容器内元素的操作

 

 list<int>::reference val = *ilist.begin();

 list<int>::reference val2 = ilist.front();

 

 c.back()

 返回容器 c 的最后一个元素的引用。如果 c 为空,则该操作未定 义

 

 

 c.front(）

 返回容器 c 的第一个元素的引用。如果 c 为空,则该操作未定义

 

 c[n]

 返回下标为 n 的元素的引用

 如果 n <0 或 n >= c.size(),则该操作未定义 只适用于 vector 和 deque 容器

 

 

 c.at(n)

 返回下标为 n 的元素的引用。如果下标越界,则该操作未定义 只适用于 vector 和 deque 容器

  

 

---删除顺序容器内元素的操作

 c.erase(p)

 

 

 删除迭代器 p 所指向的元素

 返回一个迭代器,它指向被删除元素后面的元素。如果 p 指向 容器内的最后一个元素,则返回的迭代器指向容器的超出末端 的下一位置。如果 p 本身就是指向超出末端的下一位置的迭代 器,则该函数未定义

 c.erase(b,e)

 

 

 删除迭代器 b 和 e 所标记的范围内所有的元素

 返回一个迭代器,它指向被删除元素段后面的元素。如果 e 本 身就是指向超出末端的下一位置的迭代器,则返回的迭代器也 指向容器的超出末端的下一位置

 

 

 c.clear()

 

 删除容器 c 内的所有元素。返回 void

 c.pop_back()

 

 删除容器 c 的最后一个元素。返回 void。如果 c 为空容器, 则该函数未定义

 

 c.pop_front()

 

 删除容器 c 的第一个元素。返回 void。如果 c 为空容器,则 该函数未定义

 只适用于 list 或 deque 容器

 

 选择容器类型的法则:

 1. 如果程序要求随机访问元素,则应使用 vector 或 deque 容器。

 2. 如果程序必须在容器的中间位置插入或删除元素,则应采用 list 容器。

 3. 如果程序不是在容器的中间位置,而是在容器首部或尾部插入或删除元

 素,则应采用 deque 容器。

 4. 如果只需在读取输入时在容器的中间位置插入元素,然后需要随机访问元

 素,则可考虑在输入时将元素读入到一个 list 容器,接着对此容器重新 排序,使其适合顺序访问,然后将排序后的 list 容器复制到一个 vector 容器。

 

 

 

 容器适配器

 除了顺序容器,标准库还提供了三种顺序容器适配器:queue、 priority_queue 和 stack

 #include <stack>    

 #include <queue>

 假设 deq 是 deque<int> 类型的容器,则可用 deq 初始化一个新的栈,如下所示:

 stack<int> stk(deq);