1：關聯容器和順序容器

c++中有兩種型別的容器：順序容器和關聯容器，順序容器主要有：vector、list、deque等。其中vector表示一段連續的記憶體地址，基於陣列的實現，list表示非連續的記憶體，基於連結串列實現。deque與vector類似，但是對於首元素提供刪除和插入的雙向支援。關聯容器主要有map和set。map是key-value形式的，set是單值。map和set只能存放唯一的key值，multimap和multiset可以存放多個相同的key值。

容器類自動申請和釋放記憶體，我們無需new和delete操作。

2：順序容器的介紹

1):vector，需要包含標頭檔案#include<vector>

主要的操作有

 //1.定義和初始化
     vector<int> vec1;    //預設初始化，vec1為空
     vector<int> vec2(vec1);  //使用vec1初始化vec2
     vector<int> vec3(vec1.begin(),vec1.end());//使用vec1初始化vec2
     vector<int> vec4(10);    //10個值為0的元素
     vector<int> vec5(10,4);  //10個值為4的元素
  
     //2.常用操作方法
     vec1.push_back(100
 
);            //尾部新增元素
     int size = vec1.size();         //元素個數
     bool isEmpty = vec1.empty();    //判斷是否為空
     cout<<vec1[0]<<endl;        //取得第一個元素
     vec1.insert(vec1.end(),5,3);    //從vec1.back位置插入5個值為3的元素
     vec1.pop_back();              //刪除末尾元素
     vec1.erase(vec1.begin(),vec1.begin()+2
 
);//刪除vec1[0]-vec1[2]之間的元素，不包括vec1[2]其他元素前移
    cout<<(vec1==vec2)?true:false;  //判斷是否相等==、！=、>=、<=...
     vector<int>::iterator iter = vec1.begin();    //獲取迭代器首地址
    vector<int>::const_iterator c_iter = vec1.begin();   //獲取const型別迭代器
    vec1.clear();                 //清空元素
  
     //3.遍歷
     //下標法
    int length = vec1.size();
     for(int i=0;i<length;i++)
     {
        cout<<vec1[i];
     }
     cout<<endl<<endl;
     //迭代器法
    vector<int>::iterator iter = vec1.begin();
     for(;iter != vec1.end();iter++)
     {
        cout<<*iter;
     }

2)list,list是stl實現的雙向連結串列，與向量vector想比，它允許快速的插入和刪除，但是隨機訪問卻是比較慢，需要新增標頭檔案#include<list>

主要的操作

  //1.定義和初始化
    list<int> lst1;          //建立空list
    list<int> lst2(3);       //建立含有三個元素的list
    list<int> lst3(3,2); //建立含有三個元素為2的list
    list<int> lst4(lst2);    //使用lst2初始化lst4
    list<int> lst5(lst2.begin(),lst2.end());  //同lst4
 
    //2.常用操作方法
    lst1.assign(lst2.begin(),lst2.end());  //分配值,3個值為0的元素
    lst1.push_back(10);                    //末尾新增值
    lst1.pop_back();                   //刪除末尾值
    lst1.begin();                      //返回首值的迭代器
    lst1.end();                            //返回尾值的迭代器
    lst1.clear();                      //清空值
    bool isEmpty1 = lst1.empty();          //判斷為空
    lst1.erase(lst1.begin(),lst1.end());                        //刪除元素
    lst1.front();                      //返回第一個元素的引用
    lst1.back();                       //返回最後一個元素的引用
    lst1.insert(lst1.begin(),3,2);         //從指定位置插入個3個值為2的元素
    lst1.rbegin();                         //返回第一個元素的前向指標
    lst1.remove(2);                        //相同的元素全部刪除
    lst1.reverse();                        //反轉
    lst1.size();                       //含有元素個數
    lst1.sort();                       //排序
    lst1.unique();                         //刪除相鄰重複元素
 
    //3.遍歷
    //迭代器法
    for(list<int>::const_iterator iter = lst1.begin();iter != lst1.end();iter++)
    {
       cout<<*iter;
    }

3):deque
　　deque容器類與vector類似，支援隨機訪問和快速插入和刪除，與vector不同，deque還支援從開始端插入資料：push_front。其餘的類似vector操作方法的使用.

3:關聯容器的介紹

1）map的介紹

c++map容器提供一個鍵值對(key/value)容器，map與multimap差別僅僅在於multimap允許一個鍵對應多個值。需要包含標頭檔案#include<map>。對於迭代器來說，可以修改實值，而不能修改key。map會根據key自動排序.

常用操作如下：

  //1.定義和初始化
    map<int,string> map1;                  //空map
   
    //2.常用操作方法
    map1[3] = "Saniya";                    //新增元素
    map1.insert(map<int,string>::value_type(2,"Diyabi"));//插入元素
    //map1.insert(pair<int,string>(1,"Siqinsini"));
    map1.insert(make_pair<int,string>(4,"V5"));
    string str = map1[3];                  //根據key取得value，key不能修改
    map<int,string>::iterator iter_map = map1.begin();//取得迭代器首地址
    int key = iter_map->first;             //取得key
    string value = iter_map->second;       //取得value
    map1.erase(iter_map);                  //刪除迭代器資料
    map1.erase(3);                         //根據key刪除value
    map1.size();                       //元素個數
    map1.empty();                       //判斷空
    map1.clear();                      //清空所有元素
 
    //3.遍歷
    for(map<int,string>::iterator iter = map1.begin();iter!=map1.end();iter++)
    {
       int keyk = iter->first;
       string valuev = iter->second;
    }

2)set集合
set的含義是集合，它是一個有序的容器，裡面的元素都是排序好的支援插入、刪除、查詢等操作，就像一個集合一樣，所有的操作都是嚴格在logn時間內完成，效率非常高。set和multiset的區別是：set插入的元素不能相同，但是multiset可以相同，set預設是自動排序的，使用方法類似list。

4：幾種容器的比較

1)vector

內部資料結構：陣列。

在末尾增加或者刪除元素所需時間與元素數目無關，在中間或者開頭增加或者刪除元素所需時間是隨元素數目呈線性變化。

2):deque

內部資料結構是：陣列

隨機訪問每個元素，所需要的時間為常量。在開頭和末尾增加元素所需時間與元素數目無關，在中間增加或刪除所需時間隨元素數目呈線性變化。

3)list

內部資料結構：雙向環狀連結串列

不能隨機訪問一個元素，可雙向遍歷，在開頭，末尾和中間的任何地方增加或者刪除元素所需時間都是常量。

4)set

鍵和值相等。

鍵唯一

元素預設按升序排列、

5)map

鍵唯一，

元素預設按鍵的升序排列

5：關於迭代器失效的問題、小心使用STL中的erase

 先看下面一段程式碼：

 1 #include "stdafx.h"
 2 #include<iostream>
 3 #include<vector>
 4 
 5 using namespace std;
 6 
 7 
 8 int main()
 9 {
10     vector<int> vect;
11     for(int i = 0; i < 10; i++ )
12     {
13         vect.push_back(i);
14     }
15 
16     vector<int>::iterator iter = vect.begin();
17     for(; iter != vect.end(); iter++ )
18     {
19         if( *iter % 2 == 0 )
20         {
21             vect.erase(iter);
22         }
23     }
24 
25     return 0;
26 }

咋一看這一段程式碼好像沒有什麼問題
但是執行之後的結果為:

程式直接crash了。iter是指向vector這個容器中的某個元素，如果不是在for、while迴圈中，erase刪除元素是沒有問題的，但是如果在for、while迴圈中對容器迭代，刪除其中符合條件的所有元素，就可能出現問題。vect.erase(iter)之後，iter及其後面的迭代器已經失效了，不應該再使用這些迭代器了，再執行it++,其行為是未定義的。其它容器也會遇到迭代器失效的問題。

　　對於vector被刪除元素的迭代器以及指向後面元素的迭代器全部失效。對於deque在首部或尾部刪除元素則只會使指向被刪除元素的迭代器失效，任何其它位置的插入和刪除操作將使指向該容器元素的所有迭代器失效。

　　對於list僅有指向被刪除元素的迭代器失效。為什麼不同容器迭代器失效情況有差別呢？這主要與各容器的資料結構有關。

　　那如何在迭代容器時刪除其中的元素？各容器通用的做法如下：看下面的例子

 1 #include "stdafx.h"
 2 #include<iostream>
 3 #include<vector>
 4 #include<map>
 5 #include<deque>
 6 #include<list>
 7 
 8 using namespace std;
 9 
10 
11 int main()
12 {
13     vector<int> vect;
14     for(int i = 0; i < 10; i++ )
15     {
16         vect.push_back(i);
17     }
18     vector<int>::iterator iter = vect.begin();
19     for(; iter != vect.end(); )
20     {
21          if( *iter % 2 == 0 )
22          {
23             //vect.erase(iter++); //測試 使用vect.erase(iter++) 行不通，我看網上有些人寫到這種方式也可行？表示奇怪。
24              iter = vect.erase(iter); 
25          }
26          else
27          {
28              iter++;
29          }
30     }
31 
32    //////////////////////////////下面是對deque的測試////////////////////////////
33     deque<int> myDeque;
34     for( int i = 0; i < 10; i++ )
35     {
36         myDeque.push_back(i);
37     }
38     deque<int>::iterator deiter = myDeque.begin();
39     for(; deiter != myDeque.end();)
40     {
41         if( *deiter % 2 == 0 )
42         {
43             //myDeque.erase(deiter++); //同樣這裡vect.erase(iter++) 行不通
44             deiter = myDeque.erase(deiter);
45         }
46         else
47         {
48             deiter++;
49         }
50     }
51 
52     //////////////////////////////下面對list的測試//////////////////////
53     list<int> myList;
54     for( int i = 0; i < 10; i++ )
55     {
56         myList.push_back(i);
57     }
58     list<int>::iterator listiter = myList.begin();
59     for(; listiter != myList.end();)
60     {
61         if( *listiter % 2 == 0 )
62         {
63             //myList.erase(listiter++);
64             listiter = myList.erase(listiter); //對於list這兩種方式都可以的.因為對於list來說僅有指向被刪除元素的迭代器失效，並不會導致所有的迭代器失效.
65         }
66         else
67         {
68             listiter++;
69         }
70     }
71     //////////////////////下面是對map的測試/////////////////////////////
72     map<int,int> myMap;
73     myMap[0] = 1;
74     myMap[1] = 2;
75     myMap[2] = 3;
76     myMap[3] = 4;
77     map<int,int>::iterator it = myMap.begin();
78     for(; it != myMap.end(); )
79     {
80         if( (it->second) % 2 == 0 )
81         {
82             myMap.erase(it++);
83             //it = myMap.erase(it); //對於map這兩種方法都可以 c++11 才開始支援返回當前的迭代器，之前的可能沒有返回值，所以這種方法不管用
84         }
85         else
86         {
87             it++;
88         }
89     }
90     //////////////set 跟map一樣///////////////
91     system("pause");
92     return 0;
93 }