顺序容器

概述

顺序容器类型

迭代器

string s("some string.");
//将字符串转换成大写，遇到空格或结尾停止
for(auto it = s.begin(); it != s.end() && !isspace(*it); ++it){ //begin(),end()为容器首元素迭代器和尾后迭代器，*it为解引用，也就是it指向的元素。
    *it = toupper(*it);
}

C++中，只有string和vector等标准库类型有下标运算符，并非全部类型都有。所有的容器的迭代器都定义了==和!=运算符，除了无序关联容器外都定义了关系运算符(>, >=, <, <=)，所以最好养成迭代器和!=一起使用的习惯。

容器的相等运算实际是调用元素的==运算符实现的。
而其他关系运算符是使用元素的< 运算符。如果元素类型不支持该运算符，那就不能进行关系运算。

迭代器范围

迭代器的范围为左闭右开区间[begin,end),其中begin是容器首元素，end是最后一个元素的后一个位置。

string s(10, ' ');//创建10个空格的string
for(auto it = s.begin(); it != s.end(); ++ it){
    *it = 'c'; //为迭代器指向的元素赋值
   // ++it; //指向下一元素
}

容器类型别名

通过类型别名，可以在不了解容器元素类型的情况下使用它。若需要确定元素类型，可以使用容器的value_type，如果需要元素类型的一个引用，可以使用reference或者const_reference。

list<string>::iterator iter; //通过list<string>定义的一个迭代器类型
vector<int>::defference_type count; //通过vector<int>定义的difference_type类型

顺序容器定义及初始化

每个容器类型都定义了一个默认构造函数。除array之外，其他容器的默认构造函数都会创建一个指定类型的空容器，且都可以接收指定容器大小和初值的参数。

vector<int> v; //默认构造函数，v是空的vector

vector<int>v(10); //定义大小为10int的空vector，除arraystring外都支持

vector<int>v(10,1); //创建10个元素为1的vector，除array外其他顺序容器都支持这种创建方式

array<int, 10> arr; //10个默认初始化的int
array<int, 10> arr1 = {0, 1, 2, 3}; //列表初始化
array<int, 10> arr2 = arr1; //拷贝赋值，类型大小必须都一样， 内置数组不支持这样操作

赋值和swap

c1 = c2; //将容器c1的内容替换为c2中的拷贝
c1 = {a, b, c}; //赋值后，c的大小为3

容器为array的情况：

array<int, 10> a1 = {0,1,2,3,4,5,6,7,8,9};
array<int, 10> a2 = {0}; //所有元素初始化为0
a1 = a2; //正确，array支持赋值
a2 = {0}; //错误，不能将花括号列表赋予数组。此外，array也不支持assign。

赋值运算会导致指向左边容器内部的迭代器、引用、指针失效，而swap则不会。（array和string除外。）
对于除array以外的容器，其大小不一样也可以swap，如：

vector<string> v1 = {"hello"};
vector<string> v2 = {"hi", "jack"};
swap(v1, v2);

除array外，swap只是交换两个容器内部的数据结构，并没有进行元素拷贝移动或者插入，所以速度很快。对于string，swap会导致其迭代器、引用、指针失效。

小练习：编写程序，将一个list中的char*指针元素赋值给一个vector中的string

list<char*> c = {"abc"};
vector<string> v;
v.assign(c.cbegin(), c.cend());

容器大小操作

forward_list支持max_size,empty。
其余容器都支持size,max_size,empty三种操作。

顺序容器添加元素

forward_list有自己专属的insert和emplace
forward_list不支持push_back和emplace_back
vector和string不支持push_front和emplace_front
向一个vector、string和deque插入元素会使指向其的迭代器、引用和指针失效。
向一个vector、string和deque的任何位置插入元素都是合法的，但是会很慢。

vector<string> v;
list<string> l;
//等价于调用l.push_front("Hello!");
l.insert(l.begin(), "Hello!");
//vector不支持push_front，但可以插入到begin之前，会很慢
v.insert(v.begin(), "Hello!");

将vector中的字符串赋值给list。

vector<string> v = {"tom", "jack", "rose"};
list<string> l = {"downey"};
l.insert(l.begin(), v.begin(), v.end()); //在l开头插入
l.insert(l.end(), v.begin(), v.end()); //在l末尾插入
//对于insert，返回指向其插入的第一个元素的迭代器

emplace
新标准引入emplace_front,emplace,emplace_back对应push_front,insert,push_back。
不同之处是，调用push或insert成员函数时，是将元素类型的对象传递给他们，这些对象被拷贝到容器中。而调用emplace成员函数时，是将参数传递给元素类型的构造函数，在内存空间中直接构造元素。

也就是说传递给emplace的参数必须与元素类型的构造函数参数像匹配。

访问元素

所有顺序容器都有front成员，除forward_list外都有back成员函数。

对于顺序容器,at和下标操作只适用于string,vector,deque,array。back不适用于forward_list。
容器中访问元素的成员函数(front,back，下标和at)都返回元素的引用。如容器是const对象，则返回的也是const引用。

提供快速随机访问的容器(string,vector,array,deque)都提供下标运算。

删除元素

删除deque中首尾元素之外的任何元素都会使迭代器、引用、指针失效。指向vector、string中删除点之后的位置的迭代器、引用、指针也都会失效。

特殊的forward_list插入删除操作

单向链表，无法获取一个元素的前驱节点，所以只能改变一个元素的后一个元素来实现插入删除。

改变容器大小

resize扩大或缩小容器。若当前大小>要求的大小，则容器后面的元素会被删除，如果当前大小<要求大小，会将新元素添加到容器后面。

list<int> ilist(10, 42); //10个int，每个都是42
ilist.resize(15); //5个值为0的元素添加到容器尾部。
ilist.resize(25, -1); //将10个值为-1的元素添加到ilist尾部
ilist.resize(5); //删除后面20个元素，保留前5个元素，分别都是42

如果缩小容器，则指被删除元素的迭代器指针引用都会失效。对vector,string,deque进行resize可能导致迭代器、指针、引用失效。

不要保存end返回的迭代器
因为在删除或插入vector、string或deque之外任意位置的元素后，end迭代器总会失效。

调用resize永远不会减少容器占用空间，resize只改变容器中元素个数，不改变容器容量。如果要减小，用shrink_to_fit()（不保证一定退回）。

vector<int> ivec;
//size为0，capacity依赖于具体实现
cout<< "ivec size:" << ivec.size() << endl;
cout<< "ivec capacity:" <<ivec.capacity() <<endl;

//添加24个元素
for (vector<int>::size_type ix = 0; ix != 24; ++ix){
    ivec.push_back(ix);
}
//size=24，capacity=32
cout<< "ivec size:" << ivec.size() << endl;
cout<< "ivec capacity:" <<ivec.capacity() <<endl;

vector的一个内存分配策略是，每次需要分配新的内存空间时，将当前容量翻倍。（不同实现不一样）

string的特殊操作

const char* cp = "Hello World!!";//以空字符结束的数组
char noNull[] = {'H', 'i'}; //不是以空字符结束
string s(cp); //拷贝cp中的字符，直到遇到空字符结尾。
string s1(noNull); //未定义，noNull不是以空字符结尾

改变string的其他方法
s.substr(pos, n)
返回一个string，包含从pos开始的n个字符的拷贝。如果开始位置pos超出string大小，则抛出out_of_range异常。

string除了接收迭代器版本的insert和erase之外，还提供下标版本。

s.insert(s.size(), 5, '!'); //s末尾插入5个感叹号
s.erase(s.size() - 5, 5); //从s删除最后5个字符

还有C风格字符串数组的insert和assign。

const char* cp = "Stately, plump Buck";
s.assign(cp, 7); //赋予s指针cp开始的7个字符
s.insert(s.size(), cp + 1); //s="Stately, plump Buck"

此外还有两个额外的成员函数，append和replace。
append在字符串末尾添加字符串。replace在指定位置替换字符串。

string s("hello world!");
s.append("good."); //s="hello world!good."
a.repalce(6, 5, "jack"); //s="hello jack!good." 也就是说替换字符串的长度与被替换字符串的长度不需要一样。

string的搜索操作
每个搜索操作都返回一个string::size_type值，表示匹配位置的下标。如果搜索失败，则返回名为string::npos的static成员。npos是一个unsigned类型的。

字符串比较函数

string与数值之间的转换

int i = 50;
string s = to_string(i); //将数值型转换成string

容器适配器

一个容器适配器接受一种已有类型，使其行为看起来像另一种不同的类型。
stack, queue, priorty_queue

deque<int>deq = {1, 2, 3};
stack<int> s(dep);//用容器deque对象来初始化stack对象。

默认情况下，stack和queue是基于deque实现的，priorty_queue是基于vector实现的。
stack只要求push_back,pop_back,back操作，所以可以使用除array和forward_list之外的任意顺序容器实现。queue要求back,push_back,front,push_front，因此可以基于deque和list，但不能基于vector。priority_queue除了要求front,back,push_back之外还要求随机访问，所以可以基于vector和deuqe，但不能基于list。

这是默认情况，我们也可以在创建一个适配器时，指定一个命名的顺序容器，来重载默认的容器类型。

	//vector上实现栈
	stack<int, vector<int>> int_stk;

	deque<int> dq = { 1,2,3,4,5,5 }; //默认的stack是基于deque的
	stack<int> s0(dq);
	cout << s0.size() << endl; //size=6
	vector<int> v = { 1, 2, 3, 4 };
	stack<int, vector<int>> s2(v); //将stack重载为基于vector的
	cout << s2.size() << endl; //size=4

可以看到，stack s0和s2是基于不同容器构造的。

每个容器适配器都定义了自己的特殊操作，只可以使用适配器操而不能使用底层容器的操作。