顺序容器 - 1【C++ Primer 学习笔记 - 第九章】

顺序容器:
vector :  支持快速随机访问
list      :  支持快速插入/ 删除
deque:  双端队列    double-ended queue

顺序容器适配器
stack  :                  后进先出 （LIFO）栈
queue:                  先进先出 （FIFO）队列
priority_queue  :  有优先级管理的队列

所有容器都是类模版。
所有容器都定义了默认的构造函数，用于创建 指定类型的空容器。

容器的构造函数

C<T> c;	创建空容器c .C是容器类型,如:vector;  T是元素类型,如:int . 适用所有容器
C<T> c(c2);	创建容器c2 的副本 c; 容器、元素，类型必须完全相同。适用所有容器
C<T> c(b, e);	创建容器c ; 元素是 迭代器b 和 e 范围内的元素的副本. 容器、元素，类型兼容即可。适用所有容器
C<T> c(n, t);	创建容器c;  包含 n 个值为 t 的元素. t 必须是元素类型，或者兼容的类型。 只适用于 顺序容器
C<T> c(n);	创建容器c;  包含 n 个值初始化元素。只适用于 顺序容器

const vector<int>::size_type vector_size = 10;
vector<int> ivec(vector_size, 1);
vector<int> ivec2(ivec);

// extern 关键字说明 get_word_count 定义在其他模块中
extern unsigned get_word_count(const string &file_name);
list<string> slist(get_word_count("zhangwenan"));

list<int> slist2(ivec.begin(), ivec.end());
vector<int>::iterator iter = ivec.begin() + ivec.size()/2;
deque<int> ideque(ivec.begin(), iter);

// 指针，就是迭代器。因此，允许通过内置数组的指针来初始化容器
char *words[] = {"taobao", "baidu", "google"};
size_t word_size = sizeof(words)/sizeof(char *);
list<string> slist3(words, words+word_size);

容器元素的类型，必须满足2个条件：（这是最低要求，有的容器还会有一些特殊要求）
1、元素类型支持赋值运算，     2、元素类型的对象必须可以复制
引用类型，不支持赋值，  IO 库类型不支持赋值和运算

容器的容器

vector< vector<string> > lines;

迭代器

常用迭代器运算

*iter	返回迭代器iter指向的元素的引用
iter->mem	等效于(*iter).mem， 解引用并获取mem成员
++iter iter++	iter 加1，指向下一个元素
--iter iter--	iter 减1，指向前一个元素
iter1==iter2 iter1!=iter2	比较是否相等（不等）

vector 和 deque 容器的迭代器提供了额外的运算

vector 和 deque 类型支持的操作

iter+n iter-n	产生，指向容器中前面（后面）的第n 个元素，的迭代器。不能越界
iter1 += iter2 iter1 -= iter2	复合运算
iter1 - iter2
> >= < <=	前一个迭代器，小于，后一个迭代器。比如：vec.begin() < vec.end()。不能越界

关系操作符，只适用于 vector 、 deque 容器。因为，只有这2 种容器为其元素提供快速、随机的访问。

vector<int> vec(10);
vector<int>::iterator iter = vec.begin() + vec.size()/2;

list<int> ilist(vec.begin(), vec.end());
// 以下 Error:因为，list迭代器，不支持算术运算，也不支持关系运算。
// 只支持，自增、自减、相等、不等，的运算
list<int>::iterator liter = ilist.begin() + ilist.size()/2;

迭代器范围： [ begin, end) ， 左闭合区间。 包括 begin ，但不包括 end

导致迭代器失效的容器操作， 对容器内的元素进行增加、删除等操作的时候，
会导致指向已经删除元素的迭代器，具有无效值，因为它指向了已经不存在的元素。
该问题类似于，悬垂指针（指向曾经存在的对象，但对象现在已经不存在了，这类指针）

容器定义的类型别名（所有容器都支持）

size_type	无符号整型，足以存储此容器的最大可能容器长度
iterator	此类容器的迭代器
const_iterator	元素的只读迭代器
reverse_iterator	按逆序寻址元素的迭代器
const_reverse_iterator	元素的只读逆序迭代器
difference_type	足够存储2个迭代器差值的有符号整型，可为负数
value_type	元素类型
reference	元素的左值类型，是value_type& 的同义词
const_reference	元素的常量左值类型，等效于 const value_type&

vector<int> vec(10);
// 以下2种操作
// 容器不是const，则返回类型：vector<int>::iterator 
// 容器是const，	 则返回类型：vector<int>::const_iterator 
vec.begin();
vec.end();

// 以下2种操作
// 容器不是const，则返回类型：vector<int>::reverse_iterator 
// 容器是const，	 则返回类型：vector<int>::const_reverse_iterator 
vec.rbegin();
vec.rend();

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

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 类型

容器元素都是副本

vector<string> svec;
list<string> slist;
string spouse("This is my word");

// 等价于: slist.push_front(spouse);
slist.insert(slist.begin(), spouse);

// vector 不支持 push_front();
// 但是，可以使用 insert() 达到相同的效果。
// 只是，vector 使用 insert 时，除非在末尾插入，否则程序开销比较大
svec.insert(svec.begin(), spouse);



svec.insert(svec.end(), 10, "Spaceholder");

string sarray[3] = {"google", "baidu", "qq"};
slist.insert(slist.end(), sarray, sarray+3);

vector<int> ivec(10);
vector<int>::iterator first = ivec.begin();
// vector<int>::iterator first = ivec.begin(), last = ivec.end();
// while(first != last)
// 不按照以上写法，是因为，insert() 执行之后，last迭代器已经失效。
// 因此要避免存储 end 操作返回的迭代器
while(first != ivec.end())
{
	first = ivec.insert(++first, 42);
	++first;
}

容器的关系运算

vector<int> ivec1, ivec2, ivec3, ivec4, ivec5;
/*
	ivec1: 1 3 5 7 9 12
	ivec2: 0 2 4 6 8 10 12
	ivec3: 1 3 9
	ivec4: 1 3 5 7
	ivec5: 1 3 5 7 9 12
*/
ivec1 > ivec2;	// true
ivec3 > ivec1;	// true
ivec1 > ivec4;	// true
ivec1 == ivec5;	// true

顺序容器的大小操作

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 来初始化

resize() 操作，也会使迭代器失效。