C++ STL基本容器使用

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

 先看下面一段代碼：

#include "stdafx.h"
#include<iostream>
#include<vector>

using namespace std;


int main()
{
    vector<int> vect;
    for(int i = 0; i < 10; i++ )
    {
        vect.push_back(i);
    }

    vector<int>::iterator iter = vect.begin();
    for(; iter != vect.end(); iter++ )
    {
        if( *iter % 2 == 0 )
        {
            vect.erase(iter);
        }
    }

    return 0;
}

咋一看這一段代碼好像沒有什么問題
但是運行之后的結果為:

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

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

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

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

#include "stdafx.h"
#include<iostream>
#include<vector>
#include<map>
#include<deque>
#include<list>

using namespace std;


int main()
{
    vector<int> vect;
    for(int i = 0; i < 10; i++ )
    {
        vect.push_back(i);
    }
    vector<int>::iterator iter = vect.begin();
    for(; iter != vect.end(); )
    {
         if( *iter % 2 == 0 )
         {
            //vect.erase(iter++); //測試 使用vect.erase(iter++) 行不通，我看網上有些人寫到這種方式也可行？表示奇怪。
             iter = vect.erase(iter); 
         }
         else
         {
             iter++;
         }
    }

   //////////////////////////////下面是對deque的測試////////////////////////////
    deque<int> myDeque;
    for( int i = 0; i < 10; i++ )
    {
        myDeque.push_back(i);
    }
    deque<int>::iterator deiter = myDeque.begin();
    for(; deiter != myDeque.end();)
    {
        if( *deiter % 2 == 0 )
        {
            //myDeque.erase(deiter++); //同樣這里vect.erase(iter++) 行不通
            deiter = myDeque.erase(deiter);
        }
        else
        {
            deiter++;
        }
    }

    //////////////////////////////下面對list的測試//////////////////////
    list<int> myList;
    for( int i = 0; i < 10; i++ )
    {
        myList.push_back(i);
    }
    list<int>::iterator listiter = myList.begin();
    for(; listiter != myList.end();)
    {
        if( *listiter % 2 == 0 )
        {
            //myList.erase(listiter++);
            listiter = myList.erase(listiter); //對於list這兩種方式都可以的.因為對於list來說僅有指向被刪除元素的迭代器失效，並不會導致所有的迭代器失效.
        }
        else
        {
            listiter++;
        }
    }
    //////////////////////下面是對map的測試/////////////////////////////
    map<int,int> myMap;
    myMap[0] = 1;
    myMap[1] = 2;
    myMap[2] = 3;
    myMap[3] = 4;
    map<int,int>::iterator it = myMap.begin();
    for(; it != myMap.end(); )
    {
        if( (it->second) % 2 == 0 )
        {
            myMap.erase(it++);
            //it = myMap.erase(it); //對於map這兩種方法都可以 c++11 才開始支持返回當前的迭代器，之前的可能沒有返回值，所以這種方法不管用
        }
        else
        {
            it++;
        }
    }
    //////////////set 跟map一樣///////////////
    system("pause");
    return 0;
}