各大容器特点和用途总结
基本概念
STL(标准模板库）分三类：algorithm(算法）、container(容器）和iterator（迭代器）

STL详细的六大组件：容器、算法、迭代器、仿函数、适配器、空间适配器
容器的分类

**序列式容器：**每个元素都有固定位置--取决于插入时机和地点，
和元素值无关：vector、deque、list

**关联式容器：**元素位置取决于特定的排序准则，
和插入顺序无关：set、multiset、map、multimap

- 容器

- string

string不是容器，是一个处理字符串的类，用法和容器很像
sizeof和strlen
1、string和char*的比较

string是一个类, char*是一个指向字符的指针。
    
string封装了char*，管理这个字符串，是一个char*型的容器。

string不用考虑内存释放和越界。
  
string管理char*所分配的内存。每一次string的复制，取值都由string类负责维护，不用   担心复制越界和取值越界等。

string提供了一系列的字符串操作函数（这个等下会详讲）

查找find，拷贝copy，删除erase，替换replace，插入insert

2、string的构造函数

默认构造函数

string();       //构造一个空的字符串string s1。

拷贝构造函数：

string(const string &str); //构造一个与str一样的string。如string s1(s2)。

3、string的存取字符操作

operator[]和at()均返回当前字符串中第n个字符，但二者是有区别的。
主要区别在于at()在越界时会抛出异常，[]在刚好越界时会返回(char)0，
再继续越界时，编译器直接出错。如果你的程序希望可以通过try,catch捕获异常，
建议采用at()。

4、从string取得const char*的操作

char*->string     string s="aaaa"
string->char*      s.c_str()

5、string的长度

int length() const;   //返回当前字符串的长度。长度不包括字符串结尾的'\0'。

6、string的赋值

 string &assign(const char *s); //把字符串s赋给当前的字符串

7、string字符串连接

string &append(const char *s);    //把字符串s连接到当前字符串结尾

8、string的比较

int compare(const char *s) const;   //与字符串s比较

compare函数在>时返回 1，<时返回 -1，==时返回 0。比较区分大小写，
比较时参考字典顺序，排越前面的越小。大写的A比小写的a小。

9、string的子串

string substr(int pos=0, int n=npos) const;    //返回由pos开始的n个字符组成的子字符串

10、string的查找 和 替换

int find(char c,int pos=0) const;  //从pos开始查找字符c在当前字符串的位置
int rfind(char c, int pos=npos) const;   //从pos开始从后向前查找字符c在当前
字符串中的位置

string &replace(int pos, int n, const char *s);//删除从pos开始的n个字符，
然后在pos处  插入串s
void swap(string &s2);    //交换当前字符串与s2的值

11、String的区间删除和插入

string &insert(int pos, int n, char c);  //在pos位置 插入n个字符c
string &erase(int pos=0, int n=npos);  //删除pos开始的n个字符，返回修改后的字符串

- vector容器

vector是将元素置于一个动态数组中加以管理的容器。

1、一个动态分配的数组(当数组空间内存不足时，都会执行: 分配新空间-复制元素-释放原空间);//会通过reserve预置空间提高效率
2、 当删除元素时，不会释放限制的空间，向量容器对象分配的储存空间常常比实际储存的元素个数大，前者叫向量容器的容量（capacity）可以用capacity（）成员函数获取；后者叫向量容器的大小（size），可以用size（）函数获取。向量容器的容量(capacity)大于向量容器的大小(size);
3、 vector可以随机存取元素（支持索引值直接存取，用[]操作符或at()方法）。
4、vector尾部添加或移除元素非常快速。但是在中部或头部插入元素或移除元素比较费时

• vector初始化

vector<int>v1;//默认构造
int arr[]=[1,2,3,4];
vector<int>v2(arr,arr+sieof(arr)/sizeof(int);//方法一，构造函数
vector<int>v3(v2.begin(),v2.end());方法二
vector<int>v4(v3);//方法三

• 其他函数

v.capacity();//容器容量

v.size();//容器大小

v.at(int idx);//用法和【】运算符相同

v.push_back();//尾部插入

v.pop_back();//尾部删除

v.back();//获取尾部元素

v.begin();//头元素的迭代器

v.end();//尾部元素的迭代器

v.insert(pos,elem);//pos是vector的插入元素的位置

v.insert(pos,n,elem);//在位置pos上插入n个元素elem

v.insert(pos,begin,end);

v.erase(pos);//移除pos位置上的元素，返回下一个数据的位置

v.erase(begin,end);//移除【begin,end]区间的数据，返回下一个元素的位置

reverse(pos1,pos2);//将vector中的pos1-pos2的元素逆序存储

• vector与迭代器配合使用
• 前向遍历

for(vector::iterator
it=vecInt.begin(); it!=vecInt.end(); ++it)

{

int iItem = *it;
cout << iItem; //或直接使用
cout << *it;

}

• 后向遍历
  for(vector::reverse_iterator
  rit=vecInt.rbegin(); rit!=vecInt.rend(); ++rit) //注意，小括号内仍是++rit

{

              int iItem  = *rit; 

cout << iItem; //或直接使用cout << *rit;

}

- 插入补充：用迭代器

vecA.insert(vecA.begin()+1,2,33); //{11,33,33,1,3,5,7,9}

vecA.insert(vecA.begin(), vecB.begin() , vecB.end() );  
//{2,4,6,8,11,33,33,1,3,5,7,9}

- 删除补充：用迭代器
情况一：删除指定范围元素
vecInt是用vector声明的容器，现已包含按顺序的1,3,5,6,9元素。

vector::iterator
itBegin=vecInt.begin()+1;

vector::iterator
itEnd=vecInt.begin()+2;

vecInt.erase(itBegin,itEnd);

情况二：删除指定值元素
假设 vecInt 包含1,3,2,3,3,3,4,3,5,3，删除容器中等于3的元素

for(vector::iterator it=vecInt.begin(); it!=vecInt.end(); )
//小括号里不需写 ++it

{
if(*it == 3)
{
it = vecInt.erase(it); //以迭代器为参数，删除元素3，并把数据删除后的下一个元素位置返回给迭代器。

//此时，不执行 ++it；
}
else
{
++it;
}
}
//删除vecInt的所有元素
vecInt.clear(); //容器为空

deque容器

1 特点
(1）、deque 双端队列
(2)、具有分段数组、索引数组，分段数组是储存数据的，索引数组是存储每段数组的首地址
(3)、向两端插入元素效率较高

2 创建deque对象
（1)deque< int >d1;
(2)deque< int >d2(10);
3、基本操作
（1）末尾的元素添加移除操作：

² deque.push_back(elem); //在容器尾部添加一个数据

² deque.push_front(elem); //在容器头部插入一个数据

² deque.pop_back(); //删除容器最后一个数据

² deque.pop_front(); //删除容器第一个数据

（2）deque的数据存取

deque.at(idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range。

deque[idx]; //返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。

deque.front(); //返回第一个数据。

deque.back(); //返回最后一个数据

• （3）deque与迭代器

deque.begin(); //返回容器中第一个元素的迭代器。

deque.end(); //返回容器中最后一个元素之后的迭代器。

deque.rbegin(); //返回容器中倒数第一个元素的迭代器。

deque.rend(); //返回容器中倒数最后一个元素之后的迭代器。

for (deque<int>::iterator
it=deqInt.begin(); it!=deqInt.end(); ++it)
{ cout<< *it;cout<< "";}

• （4）deque对象的带参数构造

deque(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身。注意该区间是左闭右开的区间。

deque(n,elem); //构造函数将n个elem拷贝给本身。

deque(const deque &deq); //拷贝构造函数。

• （5）deque的赋值

deque.assign(beg,end); //将[beg, end)区间中的数据拷贝赋值给本身。注意该区间是左闭右开的区间。

deque.assign(n,elem); //将n个elem拷贝赋值给本身。

deque& operator=(const deque &deq); //重载等号操作符

deque.swap(deq); // 将vec与本身的元素互换

• （6）deque的大小

deque.size(); //返回容器中元素的个数

deque.empty(); //判断容器是否为空

deque.resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

deque.resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

• （7）deque的删除

deque.clear(); //移除容器的所有数据

deque.erase(beg,end); //删除[beg,end)区间的数据，返回下一个数据的位置。

deque.erase(pos); //删除pos位置的数据，返回下一个数据的位置。

删除区间内的元素

deqInt是用deque< int >声明的容器，现已包含按顺序的1,3,5,6,9元素。

deque< int >::iterator itBegin=deqInt.begin()+1;

deque< int >::iterator itEnd=deqInt.begin()+3;

deqInt.erase(itBegin,itEnd);

//此时容器deqInt包含按顺序的1,6,9三个元素。

假设 deqInt 包含1,3,2,3,3,3,4,3,5,3，删除容器中等于3的元素

for(deque::iterator it=deqInt.being(); it!=deqInt.end(); ) //小括号里不需写 ++it

{
if(*it == 3)
{
it = deqInt.erase(it); //以迭代器为参数，删除元素3，并把数据删除后的下一个元素位置返回给迭代器。

//此时，不执行 ++it；
}
else
{
++it;
}
}

//删除deqInt的所有元素

deqInt.clear(); //容器为空

• list容器

List简介
list是一个双向链表容器，可高效地进行插入删除元素。
list不可以随机存取元素，所以不支持at.(pos)函数与[]操作符。It++(ok) it+5(err)

#include < list >

• （1）list对象的默认构造

list采用采用模板类实现,对象的默认构造形式：list lstT; 如：

list<int> lstInt;            //定义一个存放int的list容器。

list<float> lstFloat;     //定义一个存放float的list容器。

list<string> lstString;     //定义一个存放string的list容器。

… //尖括号内还可以设置指针类型或自定义类型。

• （2)list头尾的添加移除操作

list.push_back(elem); //在容器尾部加入一个元素
list.pop_back(); //删除容器中最后一个元素
list.push_front(elem); //在容器开头插入一个元素
list.pop_front(); //从容器开头移除第一个元素

• (3)list的数据存取

list.front(); //返回第一个元素。
list.back(); //返回最后一个元素。

• (4)list与迭代器

list.begin(); //返回容器中第一个元素的迭代器。

list.end(); //返回容器中最后一个元素之后的迭代器。

list.rbegin(); //返回容器中倒数第一个元素的迭代器。

list.rend(); //返回容器中倒数最后一个元素的后面的迭代器。

     for(list<int>::iterator it=lstInt.begin(); it!=lstInt.end(); ++it)
     {
              cout<< *it;
              cout<< " ";
     }

• (5)list对象的带参数构造

list(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身。注意该区间是左闭右开的区间。

list(n,elem); //构造函数将n个elem拷贝给本身。

list(const list &lst); //拷贝构造函数。

• (6)list的大小

list.size(); //返回容器中元素的个数

list.empty(); //判断容器是否为空

list.resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

list.resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

• (7)list的插入

list.insert(pos,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置。

list.insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值。

list.insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据，无返回值。

 lstA.insert(lstA.begin(), 11);             //{11, 1, 3, 5, 7, 9}
 lstA.insert(++lstA.begin(),2,33);              //{11,33,33,1,3,5,7,9}
 lstA.insert(lstA.begin()
 lstB.begin() , lstB.end() ); //{2,4,6,8,11,33,33,1,3,5,7,9}

• (8)list的删除

  list.clear();          //移除容器的所有数据
  list.erase(beg,end);  //删除[beg,end)区间的数据，返回下一个数据的位置。
  list.erase(pos);    //删除pos位置的数据，返回下一个数据的位置。
  list.remove(elem);   //删除容器中所有与elem值匹配的元素。
  

删除区间内的元素

lstInt是用list声明的容器，现已包含按顺序的1,3,5,6,9元素。

list< int >::iterator
itBegin=lstInt.begin()
++ itBegin;
list::iterator
itEnd=lstInt.begin();
++ itEnd;
++ itEnd;
++ itEnd;//不支持随机访问
list容器不支持随机访问
lstInt.erase(itBegin,itEnd);
//此时容器lstInt包含按顺序的1,6,9三个元素。

• （9）list的反序排列

lst.reverse(); //反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素。

list<int>
lstA;
lstA.push_back(1);
lstA.push_back(3);
lstA.push_back(5);
lstA.push_back(7);
lstA.push_back(9);
lstA.reverse();                   //9 7 5 3 1

• （10）排序方法二
  算法sort支持可随机访问的容器（vector)、C数组、C++11标准的std::array
  List容器不支持随机访问，自己提供算法

bool A(int v1,int v2)
{return v1>v2;}
mlist.sort(A);//从大到小排序

• stack
• queue
• set
• multiset
• map
• multimap
  未完待续~~~