STL vector用法介绍+ STL 常用函数用法

介绍

这篇文章的目的是为了介绍std::vector，如何恰当地使用它们的成员函数等操作。本文中还讨论了条件函数和函数指针在迭代算法中使用，如在remove_if()和for_each()中的使用。通过阅读这篇文章读者应该能够有效地使用vector容器，而且应该不会再去使用C类型的动态数组了。

Vector总览

vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。

为了可以使用vector，必须在你的头文件中包含下面的代码：

#include <vector>

vector属于std命名域的，因此需要通过命名限定，如下完成你的代码：

using std::vector;

vector<int> vInts;

或者连在一起，使用全名：

std::vector<int> vInts;

建议使用全局的命名域方式：

using namespace std;

在后面的操作中全局的命名域方式会造成一些问题。vector容器提供了很多接口，在下面的表中列出vector的成员函数和操作。

Vector成员函数

函数	表述
c.assign(beg,end) c.assign(n,elem)	将[beg; end)区间中的数据赋值给c。将n个elem的拷贝赋值给c。
c.at(idx)	传回索引idx所指的数据，如果idx越界，抛出out_of_range。
c.back()	传回最后一个数据，不检查这个数据是否存在。
c.begin()	传回迭代器重的可一个数据。
c.capacity()	返回容器中数据个数。
c.clear()	移除容器中所有数据。
c.empty()	判断容器是否为空。
c.end()	指向迭代器中的最后一个数据地址。
c.erase(pos) c.erase(beg,end)	删除pos删除[beg,end)区间的数据，传回下一个数据的位置。
c.front()	传回第一个数据。
get_allocator	使用构造函数返回一个拷贝。
c.insert(pos,elem) c.insert(pos,n,elem) c.insert(pos,beg,end)	在poselem拷贝，传回新数据位置。在posn个elem数据。无返回值。在pos[beg,end)区间的数据。无返回值。
c.max_size()	返回容器中最大数据的数量。
c.pop_back()	删除最后一个数据。
c.push_back(elem)	在尾部加入一个数据。
c.rbegin()	传回一个逆向队列的第一个数据。
c.rend()	传回一个逆向队列的最后一个数据的下一个位置。
c.resize(num)	重新指定队列的长度。
c.reserve()	保留适当的容量。
c.size()	返回容器中实际数据的个数。
c1.swap(c2) swap(c1,c2)	将c1和c2元素互换。同上操作。
vector<Elem> c vector <Elem> c1(c2) vector <Elem> c(n) vector <Elem> c(n, elem) vector <Elem> c(beg,end) c.~ vector <Elem>()	创建一个空的vector。复制一个vector。创建一个vector，含有n个数据，数据均已缺省构造产生。创建一个含有n个elem拷贝的vector。创建一个以[beg;end)区间的vector。销毁所有数据，释放内存。

Vector操作

函数	描述
operator[]	返回容器中指定位置的一个引用。

创建一个vector

vector容器提供了多种创建方法，下面介绍几种常用的。

创建一个Widget类型的空的vector对象：

vector<Widget> vWidgets;

// ------

// |

// |- Since vector is a Container, its member functions

// operate on iterators and the container itself so

// it can hold objects of any type.

创建一个包含500个Widget类型数据的vector：

vector<Widget> vWidgets(500);

创建一个包含500个Widget类型数据的vector，并且都初始化为0：

vector<Widget> vWidgets(500, Widget(0));

创建一个Widget的拷贝：

vector<Widget> vWidgetsFromAnother(vWidgets);

向vector添加一个数据

vector添加数据的缺省方法是push_back()。push_back()函数表示将数据添加到vector的尾部，并按需要来分配内存。例如：向vector<Widget>中添加10个数据，需要如下编写代码：

for(int i= 0;i<10; i++)

vWidgets.push_back(Widget(i));

获取vector中制定位置的数据

很多时候我们不必要知道vector里面有多少数据，vector里面的数据是动态分配的，使用push_back()的一系列分配空间常常决定于文件或一些数据源。如果你想知道vector存放了多少数据，你可以使用empty()。获取vector的大小，可以使用size()。例如，如果你想获取一个vector v的大小，但不知道它是否为空，或者已经包含了数据，如果为空想设置为-1，你可以使用下面的代码实现：

int nSize = v.empty() ? -1 : static_cast<int>(v.size());

访问vector中的数据

使用两种方法来访问vector。

1、 vector::at()

2、 vector::operator[]

operator[]主要是为了与C语言进行兼容。它可以像C语言数组一样操作。但at()是我们的首选，因为at()进行了边界检查，如果访问超过了vector的范围，将抛出一个例外。由于operator[]容易造成一些错误，所有我们很少用它，下面进行验证一下：

分析下面的代码：

vector<int> v;

v.reserve(10);

for(int i=0; i<7; i++)

v.push_back(i);

try

{

int iVal1 = v[7]; // not bounds checked - will not throw

int iVal2 = v.at(7); // bounds checked - will throw if out of range

}

catch(const exception& e)

{

cout << e.what();

}

我们使用reserve()分配了10个int型的空间，但并不没有初始化。

你可以在这个代码中尝试不同条件，观察它的结果，但是无论何时使用at()，都是正确的。

删除vector中的数据

vector能够非常容易地添加数据，也能很方便地取出数据，同样vector提供了erase()，pop_back()，clear()来删除数据，当你删除数据的时候，你应该知道要删除尾部的数据，或者是删除所有数据，还是个别的数据。在考虑删除等操作之前让我们静下来考虑一下在STL中的一些应用。

Remove_if()算法

现在我们考虑操作里面的数据。如果要使用remove_if()，我们需要在头文件中包含如下代码：：

#include <algorithm>

Remove_if()有三个参数：

1、 iterator _First：指向第一个数据的迭代指针。

2、 iterator _Last：指向最后一个数据的迭代指针。

3、 predicate _Pred：一个可以对迭代操作的条件函数。

条件函数

条件函数是一个按照用户定义的条件返回是或否的结果，是最基本的函数指针，或者是一个函数对象。这个函数对象需要支持所有的函数调用操作，重载operator()()操作。remove_if()是通过unary_function继承下来的，允许传递数据作为条件。

例如，假如你想从一个vector<CString>中删除匹配的数据，如果字串中包含了一个值，从这个值开始，从这个值结束。首先你应该建立一个数据结构来包含这些数据，类似代码如下：

#include <functional>

enum findmodes

{

FM_INVALID = 0,

FM_IS,

FM_STARTSWITH,

FM_ENDSWITH,

FM_CONTAINS

};

typedef struct tagFindStr

{

UINT iMode;

CString szMatchStr;

} FindStr;

typedef FindStr* LPFINDSTR;

然后处理条件判断：

class FindMatchingString

: public std::unary_function<CString, bool>

{

public:

FindMatchingString(const LPFINDSTR lpFS) : m_lpFS(lpFS) {}

bool operator()(CString& szStringToCompare) const

{

bool retVal = false;

switch(m_lpFS->iMode)

{

case FM_IS:

{

retVal = (szStringToCompare == m_lpFDD->szMatchStr);

break;

}

case FM_STARTSWITH:

{

retVal = (szStringToCompare.Left(m_lpFDD->szMatchStr.GetLength())

== m_lpFDD->szWindowTitle);

break;

}

case FM_ENDSWITH:

{

retVal = (szStringToCompare.Right(m_lpFDD->szMatchStr.GetLength())

== m_lpFDD->szMatchStr);

break;

}

case FM_CONTAINS:

{

retVal = (szStringToCompare.Find(m_lpFDD->szMatchStr) != -1);

break;

}

return retVal;

}

private:

LPFINDSTR m_lpFS;

};

通过这个操作你可以从vector中有效地删除数据：

// remove all strings containing the value of

// szRemove from vector<CString> vs.

FindStr fs;

fs.iMode = FM_CONTAINS;

fs.szMatchStr = szRemove;

vs.erase(std::remove_if(vs.begin(), vs.end(), FindMatchingString(&fs)), vs.end());

Remove_if()能做什么？

你可能会疑惑，对于上面那个例子在调用remove_if()的时候还要使用erase()呢？这是因为大家并不熟悉STL中的算法。Remove(),remove_if()等所有的移出操作都是建立在一个迭代范围上的，那么不能操作容器中的数据。所以在使用remove_if()，实际上操作的时容器里数据的上面的。思考上面的例子：

1、 szRemove = “o”.

2、 vs见下面图表中的显示。

观察这个结果，我们可以看到remove_if()实际上是根据条件对迭代地址进行了修改，在数据的后面存在一些残余的数据，那些需要删除的数据。剩下的数据的位置可能不是原来的数据，但他们是不知道的。

调用erase()来删除那些残余的数据。注意上面例子中通过erase()删除remove_if()的结果和vs.enc()范围的数据。

压缩一个臃肿的vector

很多时候大量的删除数据，或者通过使用reserve()，结果vector的空间远远大于实际需要的。所有需要压缩vector到它实际的大小。resize()能够增加vector的大小。Clear()仅仅能够改变缓存的大小，所有的这些对于vector释放内存等九非常重要了。如何来解决这些问题呢，让我们来操作一下。

我们可以通过一个vector创建另一个vector。让我们看看这将发生什么。假定我们已经有一个vector v，它的内存大小为1000，当我们调用size()的时候，它的大小仅为7。我们浪费了大量的内存。让我们在它的基础上创建一个vector。

std::vector<CString> vNew(v);

cout << vNew.capacity();

vNew.capacity()返回的是7。这说明新创建的只是根据实际大小来分配的空间。现在我们不想释放v，因为我们要在其它地方用到它，我们可以使用swap()将v和vNew互相交换一下？

vNew.swap(v);

cout << vNew.capacity();

cout << v.capacity();

有趣的是：vNew.capacity()是1000，而v.capacity()是7。

现在是达到我的目的了，但是并不是很好的解决方法，我们可以像下面这么写：

std::vector<CString>(v).swap(v);

你可以看到我们做了什么？我们创建了一个临时变量代替那个命名的，然后使用swap(),这样我们就去掉了不必要的空间，得到实际大小的v。

结论

我希望这个文档可以给那些使用STL vector容器的开发者很有价值的参考。我也希望通过阅读这篇文章你可以放心地使用vector来代替C语言中的数据了。

======================================================我是分割线============================================================

　迭代器（iterator）

　　个人理解就是把所有和迭代有关的东西给抽象出来的，不管是数组的下标，指针，for里面的、list里面的、vector里面的，抽象一下变成了iterator

       
#include <iostream>
#include <vector>

using namespace std;  5 
int main()  7 {  8     vector<int> v;  9     for(int i = 0; i < 10; ++i ) 10  { 11  v.push_back(i); 12  } 13     for(vector<int>::iterator it = v.begin(); it != v.end(); ++it) 14  { 15         cout << *it << " "; 16  } 17     cout << endl; 18     return 0; 19 }       

　　求和（<numeric> accumulate）

　　accumulate(v.begin(),v.end(),0),把从 v.begin() 开始到 v.end()结束所有的元素加到 0上面去

   View Code 

　　vector（动态数组）

　　vector有内存管理的机制，也就是说对于插入和删除，vector可以动态调整所占用的内存空间。　　

　 vector相关函数

       
#include <iostream>
#include <vector>

using namespace std;  5 
int main()  7 {  8     vector<int> v;  9     v.push_back(3);  //数组尾部插入3
   v.push_back(2); 11     v.push_back(1); 12     v.push_back(0); 13     cout << " 下标 " << v[3] << endl; 14     cout << " 迭代器 " << endl; 15     for(vector<int>::iterator i = v.begin();i!= v.end();++i) 16  { 17         cout << *i << " "; 18  } 19     cout << endl; 20     //在第一个元素之前插入111 insert begin+n是在第n个元素之前插入
   v.insert(v.begin(),111); 22     //在最后一个元素之后插入222 insert end + n 是在n个元素之后插入
   v.insert(v.end(),222); 24 
   for(vector<int>::iterator i = v.begin();i!= v.end();++i) 26  { 27         cout << *i << " "; 28  } 29     cout << endl; 30 
   vector<int> arr(10); 32     for(int i = 0; i < 10; i++) 33  { 34         arr[i] = i; 35  } 36     for(vector<int>::iterator i = arr.begin();i!= arr.end();++i) 37  { 38         cout << *i << " "; 39  } 40     cout << endl; 41 
   //删除 同insert
arr.erase(arr.begin()); 44 
   for(vector<int>::iterator i = arr.begin();i!= arr.end();++i) 46  { 47         cout << *i << " " ; 48  } 49     cout << endl ; 50 
   arr.erase(arr.begin(),arr.begin()+5); 52 
   for(vector<int>::iterator i = arr.begin();i!= arr.end();++i) 54  { 55         cout << *i << " " ; 56  } 57     cout << endl ; 58     return 0 ; 59  }       

　　数组转置 (<algorithm> reverse)

　　reverse(v.begin(),v.end())

       
#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;  6 
int main()  8 {  9     vector<int> v; 10     for(int i = 0; i < 10; ++i) 11  { 12  v.push_back(i); 13  } 14     for(vector<int>::iterator it = v.begin(); it != v.end(); ++it) 15  { 16         cout << *it << " "; 17  } 18     cout << endl; 19 
reverse(v.begin(),v.end()); 21 

   for(vector<int>::iterator it = v.begin(); it != v.end(); ++it) 24  { 25         cout << *it << " "; 26  } 27     cout << endl; 28     return 0; 29 }       

　　排序（<algorithm> sort）

　　sort(v.begin(),v.end())

       
#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;  6 
bool Comp(const int &a,const int &b)  8 {  9     return a>b; 10 } 11 
int main() 13 { 14     vector<int> v; 15     v.push_back(1); 16     v.push_back(3); 17     v.push_back(2); 18     v.push_back(55); 19     v.push_back(-1); 20     v.push_back(0); 21     v.push_back(2); 22     v.push_back(3); 23     v.push_back(4); 24 
   for(vector<int>::iterator it = v.begin(); it != v.end(); ++it) 26  { 27         cout << *it << " "; 28  } 29     cout << endl; 30 
   //默认升序
sort(v.begin(),v.end()); 33 

   for(vector<int>::iterator it = v.begin(); it != v.end(); ++it) 36  { 37         cout << *it << " "; 38  } 39     cout << endl; 40 
   //用降序 需要自定义一个降序函数
sort(v.begin(),v.end(),Comp); 43 

   for(vector<int>::iterator it = v.begin(); it != v.end(); ++it) 46  { 47         cout << *it << " "; 48  } 49     cout << endl; 50 
   return 0; 52 }       

　 字符串（<string>）

　　输入

       
#include<iostream>
#include<string>
#include<cstdio>

using namespace std;  6 
int main()  8 {  9     string s1; 10     s1 = "hello"; 11 
   string s2; 13     char s[1024]; 14     //scanf 输入速度比cin快的多 15     //scanf 是C函数，不可以输入string
   scanf("%s",s); 17     s2 = s; 18 
   cout << s1 << endl; 20     cout << s2 << endl; 21 
   return 0; 23 }       

　　尾部添加字符字符串直接用+号例如： s += 'a'; s += "abc",或者使用append方法，s.append（“123”）

　　删除（erase clear）

　　s.erase(it + 1,it + 4); clear（）

       
#include<iostream>
#include<string>

using namespace std;  5 
int main()  7 {  8     string s;  9     s = "0123456789"; 10     cout << s << endl; 11 
   string::iterator it = s.begin(); 13 
   //删除s[3]
   s.erase(it+3); 16     cout << s << endl; 17 
   //删除s[1]~s[3]
   s = "0123456789"; 20     s.erase(it + 1,it + 4); 21     cout << s << endl; 22 
   //全部删除
s.clear(); 25     cout << "clear : " << s << endl; 26 
   return 0; 28 }       

　　查找（find）

　　用find找到string里面第一个要找到元素（char或者串），找到返回数组下标，找不到返回end（）迭代器

　　string和vector有很多相同的东西，比如length（），size（），empty（），reverse（），相对也容易，就不一一说了。

　　数字化处理（string）

　　经常会遇到这样一种情况，有一个数字，需要把每一位给提取出来，如果用取余数的方法，花费的时间就会很长，所以可以当成字符串来处理，方便、省时。

　　例子：求一个整数各位数的和

       
#include<iostream>
#include<string>

using namespace std;  5 
int main()  7 {  8     string s;  9     s = "123456789"; 10     int sum = 0; 11     for(int i = 0; i < s.size(); ++i) 12  { 13         switch(s[i]) 14  { 15             case '1': sum += 1;break; 16             case '2': sum += 2;break; 17             case '3': sum += 3;break; 18             case '4': sum += 4;break; 19             case '5': sum += 5;break; 20             case '6': sum += 6;break; 21             case '7': sum += 7;break; 22             case '8': sum += 8;break; 23             case '9': sum += 9;break; 24  } 25  } 26     
   cout << sum << endl; 28     
   return 0; 30 }       

　　string与char *

   View Code 

　　sscanf

   View Code 

　　string与数值相互转换( sprintf <sstream> )

       
#include<iostream>
#include<string>
#include<sstream>
#include<cstdio>

using namespace std;  7 
//c++ 方法 把数转换为string
string converToString(double x) 10 { 11  ostringstream o; 12     if( o << x) 13  { 14         // str()没有'\0' c_str有
       return o.str(); 16  } 17     return "error"; 18 } 19 
double converFromString(const string &s) 21 { 22  istringstream i(s); 23     double x; 24     if( i >> x) 25  { 26         return x; 27  } 28     //if error
   return 0.0; 30 } 31 int main() 32 { 33     char b[100]; 34     string s1; 35 
   //c语言方法
   sprintf(b,"%d",1987); 38     s1 = b; 39     cout << s1 << endl; 40 
   string s2 = converToString(1954); 42     cout << s2 << endl; 43 
   string s3 = "202"; 45     int c = converFromString(s3); 46     cout << c << endl; 47 
   string s4 = "casacsa6"; 49     int d = converFromString(s4); 50     cout << d << endl; 51 
   string s5 = "21abf4"; 53     int f = converFromString(s5); 54     cout << f << endl; 55 
   return 0; 57 }       

　　set容器

　　set是用红黑树的平衡二叉索引树的数据结构来实现的，插入时，它会自动调节二叉树排列，把元素放到适合的位置，确保每个子树根节点的键值大于左子树所有的值、小于右子树所有的值，插入重复数据时会忽略。set迭代器采用中序遍历，检索效率高于vector、deque、list，并且会将元素按照升序的序列遍历。set容器中的数值，一经更改，set会根据新值旋转二叉树，以保证平衡，构建set就是为了快速检索（python中的set一旦建立就是一个常量，不能改的）。

　　multiset，与set不同之处就是它允许有重复的键值。

　　正反遍历，迭代器iterator、reverse_iterator

       
#include<iostream>
#include<set>

using namespace std;  5 
int main()  7 {  8     set<int> v;  9     v.insert(1); 10     v.insert(3); 11     v.insert(5); 12     v.insert(2); 13     v.insert(4); 14     v.insert(3); 15 
   //中序遍历 升序遍历
   for(set<int>::iterator it = v.begin(); it != v.end(); ++it) 18  { 19         cout << *it << " "; 20  } 21     cout << endl; 22 
   for(set<int>::reverse_iterator rit = v.rbegin(); rit != v.rend(); ++rit) 24  { 25         cout << *rit << " "; 26  } 27     cout << endl; 28 
   return 0; 30 }       

　　自定义比较函数，insert的时候，set会使用默认的比较函数（升序），很多情况下需要自己编写比较函数。

　　1、如果元素不是结构体，可以编写比较函数，下面这个例子是用降序排列的（和上例插入数据相同）：

       
#include<iostream>
#include<set>

using namespace std;  5 
struct Comp  7 {  8     //重载()
   bool operator()(const int &a, const int &b) 10  { 11         return a > b; 12  } 13 }; 14 int main() 15 { 16     set<int,Comp> v; 17     v.insert(1); 18     v.insert(3); 19     v.insert(5); 20     v.insert(2); 21     v.insert(4); 22     v.insert(3); 23   
   for(set<int,Comp>::iterator it = v.begin(); it != v.end(); ++it) 25  { 26         cout << *it << " "; 27  } 28     cout << endl; 29 
   for(set<int,Comp>::reverse_iterator rit = v.rbegin(); rit != v.rend(); ++rit) 31  { 32         cout << *rit << " "; 33  } 34     cout << endl; 35 
   return 0; 37 }       

　　2、元素本身就是结构体，直接把比较函数写在结构体内部，下面的例子依然降序：

       
#include<iostream>
#include<set>
#include<string>

using namespace std;  6 
struct Info  8 {  9     string name; 10     double score; 11 
   //重载 <
   bool operator < (const Info &a) const
{ 15         return a.score < score; 16  } 17 }; 18 int main() 19 { 20     set<Info> s; 21  Info info; 22 
   info.name = "abc"; 24     info.score = 123.3; 25  s.insert(info); 26 
   info.name = "EDF"; 28     info.score = -23.53; 29  s.insert(info); 30 

   info.name = "xyz"; 33     info.score = 73.3; 34  s.insert(info); 35     
   for(set<Info>::iterator it = s.begin(); it != s.end(); ++it) 37  { 38         cout << (*it).name << ":" << (*it).score << endl; 39  } 40     cout << endl; 41 
   for(set<Info>::reverse_iterator rit = s.rbegin(); rit != s.rend(); ++rit) 43  { 44         cout << (*rit).name << ":" << (*rit).score << endl; 45  } 46     cout << endl; 47 
   return 0; 49 }       

　　multiset与set的不同之处就是key可以重复，以及erase（key）的时候会删除multiset里面所有的key并且返回删除的个数。

　　map

　　map也是使用红黑树，他是一个键值对（key：value映射），便利时依然默认按照key程序的方式遍历，同set。

       
#include<iostream>
#include<map>
#include<string>

using namespace std;  6 
int main()  8 {  9     map<string,double> m; 10 
   //声明即插入
   m["li"] = 123.4; 13     m["wang"] = 23.1; 14     m["zhang"] = -21.9; 15     m["abc"] = 12.1; 16     for(map<string,double>::iterator it = m.begin(); it != m.end(); ++it) 17  { 18         //first --> key second --> value
       cout << (*it).first << ":" << (*it).second << endl; 20  } 21     cout << endl; 22     return 0; 23 }       

　　用map实现数字分离

　　string --> number

　　之前用string进行过数字分离，现在使用map

       
#include<iostream>
#include<map>
#include<string>

using namespace std;  6 
int main()  8 {  9     map<char,int> m; 10 
   m['0'] = 0; 12     m['1'] = 1; 13     m['2'] = 2; 14     m['3'] = 3; 15     m['4'] = 4; 16     m['5'] = 5; 17     m['6'] = 6; 18     m['7'] = 7; 19     m['8'] = 8; 20     m['9'] = 9; 21     /*
等价于 23  for(int i = 0; i < 10; ++i) 24  { 25  m['0' + i] = i; 26  } 27     */

   string sa; 30     sa = "9876543210"; 31     int sum = 0; 32     for( int i = 0; i < sa.length(); ++i) 33  { 34         sum += m[sa[i]]; 35  } 36     cout << sum << endl; 37     return 0; 38 }       

　　number --> string

       
#include <iostream>
#include <map>
#include <string>

using namespace std;  6 
int main()  8 {  9     map<int,char> m; 10 
   for(int i = 0; i < 10; ++i) 12  { 13         m[i] = '0' + i; 14  } 15 
   int n = 7; 17 
   string out = "the number is :"; 19     cout << out + m[n] << endl; 20 
   return 0; 22 }       

　　multimap

　　multimap由于允许有重复的元素，所以元素插入、删除、查找都与map不同。

　　插入insert（pair<a,b>(value1,value2)）

       
#include <iostream>
#include <map>
#include <string>

using namespace std;  6 
int main()  8 {  9     multimap<string,double> m; 10 
   m.insert(pair<string,double>("Abc",123.2)); 12     m.insert(pair<string,double>("Abc",123.2)); 13     m.insert(pair<string,double>("xyz",-43.2)); 14     m.insert(pair<string,double>("dew",43.2)); 15 
   for(multimap<string,double>::iterator it = m.begin(); it != m.end(); ++it ) 17  { 18         cout << (*it).first << ":" << (*it).second << endl; 19  } 20     cout << endl; 21 
   return 0; 23 }       

　　至于删除和查找，erase（key）会删除掉所有key的map，查找find（key）返回第一个key的迭代器

　　deque

　　deque和vector一样,采用线性表，与vector唯一不同的是，deque采用的分块的线性存储结构，每块大小一般为512字节，称为一个deque块，所有的deque块使用一个Map块进行管理，每个map数据项记录各个deque块的首地址，这样以来，deque块在头部和尾部都可已插入和删除元素，而不需要移动其它元素。使用push_back()方法在尾部插入元素，使用push_front()方法在首部插入元素，使用insert()方法在中间插入元素。一般来说，当考虑容器元素的内存分配策略和操作的性能时，deque相对vectore更有优势。(下面这个图，我感觉Map块就是一个list< map<deque名字，deque地址> >)

　　插入删除

　　遍历当然可以使用下标遍历，在这里使用迭代器。

       
#include <iostream>
#include <deque>

using namespace std;  5 
int main()  7 {  8     deque<int> d;  9 
   //尾部插入
   d.push_back(1); 12     d.push_back(3); 13     d.push_back(2); 14     for(deque<int>::iterator it = d.begin(); it != d.end(); ++it ) 15  { 16         cout << (*it) << " "; 17  } 18     cout << endl << endl; 19 
   //头部插入
   d.push_front(10); 22     d.push_front(-23); 23     for(deque<int>::iterator it = d.begin(); it != d.end(); ++it ) 24  { 25         cout << (*it) << " "; 26  } 27     cout << endl << endl; 28 
   d.insert(d.begin() + 2,9999); 30     for(deque<int>::iterator it = d.begin(); it != d.end(); ++it ) 31  { 32         cout << (*it) << " "; 33  } 34     cout << endl << endl; 35 
   //反方向遍历
   for(deque<int>::reverse_iterator rit = d.rbegin(); rit != d.rend(); ++rit ) 38  { 39         cout << (*rit) << " "; 40  } 41     cout << endl << endl; 42 
   //删除元素pop pop_front从头部删除元素 pop_back从尾部删除元素 erase中间删除 clear全删
d.clear(); 45     d.push_back(1); 46     d.push_back(2); 47     d.push_back(3); 48     d.push_back(4); 49     d.push_back(5); 50     d.push_back(6); 51     d.push_back(7); 52     d.push_back(8); 53     for(deque<int>::iterator it = d.begin(); it != d.end(); ++it ) 54  { 55         cout << (*it) << " "; 56  } 57     cout << endl; 58 
d.pop_front(); 60  d.pop_front(); 61     for(deque<int>::iterator it = d.begin(); it != d.end(); ++it ) 62  { 63         cout << (*it) << " "; 64  } 65     cout << endl; 66 
d.pop_back(); 68  d.pop_back(); 69     for(deque<int>::iterator it = d.begin(); it != d.end(); ++it ) 70  { 71         cout << (*it) << " "; 72  } 73     cout << endl; 74 
   d.erase(d.begin() + 1); 76     for(deque<int>::iterator it = d.begin(); it != d.end(); ++it ) 77  { 78         cout << (*it) << " "; 79  } 80     cout << endl; 81     return 0; 82 }       

　　list

　　list<int> l

　　插入：push_back尾部，push_front头部，insert方法前往迭代器位置处插入元素，链表自动扩张，迭代器只能使用++--操作，不能用+n -n，因为元素不是物理相连的。

　　遍历：iterator和reverse_iterator正反遍历

　　删除：pop_front删除链表首元素；pop_back()删除链表尾部元素；erase（迭代器）删除迭代器位置的元素，注意只能使用++--到达想删除的位置；remove（key）删除链表中所有key的元素，clear（）清空链表。

　　查找：it = find(l.begin(),l.end(),key)

　　排序：l.sort()

　　删除连续重复元素:l.unique() 【2 8 1 1 1 5 1】 --> 【 2 8 1 5 1】

　　bitset

　　从来没用过，上两幅图吧就：

　　stack（后进先出）

　　这个印象深刻，学数据结构的时候做表达式求值的就是用的栈。

       
#include <iostream>
#include <stack>
using namespace std;  4 
int main()  6 {  7 
   stack<int> s;  9     s.push(1); 10     s.push(2); 11     s.push(4); 12     s.push(5); 13 
   cout << s.size() << endl; 15 
   while(s.empty() != true) 17  { 18         cout << s.top() << endl; 19  s.pop(); 20  } 21     return 0; 22 }       

　　stack然我唯一费解之处在于，貌似它没有iterator，可以试试s.begin()编译器报错的。

　　queue（先进先出）

　　queue有入队push（插入）、出队pop（删除）、读取队首元素front、读取队尾元素back、empty，size这几种方法

　　priority_queue(最大元素先出)

       
#include <iostream>
#include <queue>
using namespace std;  4 
int main()  6 {  7 
   priority_queue<int> pq;  9 
   pq.push(1); 11     pq.push(3); 12     pq.push(2); 13     pq.push(8); 14     pq.push(9); 15     pq.push(0); 16 
   cout << "size: " << pq.size() << endl; 18 
   while(pq.empty() != true) 20  { 21         cout << pq.top() << endl; 22  pq.pop(); 23  } 24     return 0; 25 }       

　　重载操作符同set重载操作符。