1. 程式人生 > >STL提供了三個最基本的容器:vector,list,deque。

STL提供了三個最基本的容器:vector,list,deque。

 vector和built-in陣列類似,它擁有一段連續的記憶體空間,並且起始地址不變,因此它能非常好的支援隨機存取,即[]操作符,但由於它的記憶體空間是連續的,所以在中間進行插入和刪除會造成記憶體塊的拷貝,另外,當該陣列後的記憶體空間不夠時,需要重新申請一塊足夠大的記憶體並進行記憶體的拷貝。這些都大大影響了vector的效率。 list就是資料結構中的雙向連結串列(根據sgi   stl原始碼),因此它的記憶體空間可以是不連續的,通過指標來進行資料的訪問,這個特點使得它的隨機存取變的非常沒有效率,因此它沒有提供[]操作符的過載。但由於連結串列的特點,它可以以很好的效率支援任意地方的刪除和插入。

 
   
  deque是一個double-ended queue,它的具體實現不太清楚,但知道它具有以下兩個特點:它支援[]操作符,也就是支援隨即存取,並且和vector的效率相差無幾,它支援在兩端的操作:push_back、push_front、pop_back、pop_front等,並且在兩端操作上與list的效率也差不多。
 
   
  因此在實際使用時,如何選擇這三個容器中哪一個,應根據你的需要而定,一般應遵循下面的原則:
 
      1、如果你需要高效的隨即存取,而不在乎插入和刪除的效率,使用
vector  
      2、如果你需要大量的插入和刪除,而不關心隨即存取,則應使用
list  
      3、如果你需要隨即存取,而且關心兩端資料的插入和刪除,則應使用deque。

STL是 C++的ANSI/ISO 標準的一部分,可以用於所有C++語言編譯器和所有平臺。STL的同一版本在任意硬體配置下都是可用的;STL 提供了大量的可複用軟體組織。例如,程式設計師再也不用自己設計排序,搜尋演算法了,這些都已經是STL的一部分了。使用STL編寫的程式碼更容易修改和閱讀,因為程式碼更短了,很多基礎工作程式碼已經被元件化了。

STL 的組成
  STL有三大核心部分:容器(Container)、演算法(Algorithms)、迭代器(Iterator),容器介面卡(container adaptor),函式物件(functor),除此之外還有STL其他標準組件。

容器(container):

容器是資料在記憶體中組織的方法,例如,陣列、堆疊、佇列、連結串列或二叉樹(不過這些都不是STL標準容器)。STL中的容器是一種儲存T(Template)型別值的有限集合的資料結構,容器的內部實現一般是類。這些值可以是物件本身,如果資料型別T代表的是Class的話。

演算法(algorithm):

演算法是應用在容器上以各種方法處理其內容的行為或功能。例如,有對容器內容排序、複製、檢索和合並的演算法。在STL中,演算法是由模板函式表現的。這些函式不是容器類的成員函式。相反,它們是獨立的函式。令人吃驚的特點之一就是其演算法如此通用。不僅可以將其用於 STL容器,而且可以用於普通的C++陣列或任何其他應用程式指定的容器。
迭代器(iterator):

一旦選定一種容器型別和資料行為(演算法),那麼剩下唯一要他做的就是用迭代器使其相互作用。可以把迭代器看作一個指向容器中元素的普通指標。可以如遞增一個指標那樣遞增迭代器,使其依次指向容器中每一個後繼的元素。迭代器是STL的一個關鍵部分,因為它將演算法和容器連在一起。

下面我將依次介紹STL的這三個主要元件

容器
  STL中的容器有佇列容器和關聯容器,容器介面卡(congtainer adapters:stack,queue,priority queue),位集(bit_set),串包(string_package)等等。
  在本文中,我將介紹list,vector,deque等佇列容器,和set和multisets,map和multimaps等關聯容器,一共7種基本容器類。
佇列容器(順序容器):佇列容器按照線性排列來儲存T型別值的集合,佇列的每個成員都有自己的特有的位置。順序容器有向量型別、雙端佇列型別、列表型別三種。
基本容器——順序容器
向量(vector容器類):#include <vector>,vector是一種動態陣列,是基本陣列的類模板。其內部定義了很多基本操作。既然這是一個類,那麼它就會有自己的建構函式。vector 類中定義了4種建構函式:

預設建構函式,構造一個初始長度為0的空向量
如:vector<int> v1;
帶有單個整形引數的建構函式,此引數描述了向量的初始大小。這個建構函式還有一個可選的引數,這是一個型別為T的例項,描述了各個向量種各成員的初始值;
如:vector<int> v2(init_size,0); 如果預先定義了:int init_size;他的成員值都被初始化為0;
複製建構函式,構造一個新的向量,作為已存在的向量的完全複製,
如:vector<int> v3(v2);
帶兩個常量引數的建構函式,產生初始值為一個區間的向量。區間由一個半開區間[first,last](MS word的顯示可能會有問題,first前是一個左方括號,last後面是一個右圓括號)來指定。
如:vector<int> v4(first,last)
下面一個例子用的是第四種構造方法,其它的方法讀者可以自己試試。


//stl_cpp_7.cpp
//程式:初始化演示
#include <cstring> 
#include <vector>
#include <iostream>
using namespace std;
int ar[10] = {  12, 45, 234, 64, 12, 35, 63, 23, 12, 55  };
char* str = "Hello World";
int main(void)
{
    vector <int> vec1(ar, ar+10);                //first=ar,last=ar+10,不包括ar+10
    vector <char> vec2(str, str+strlen(str));    //first=str,last= str+strlen(str),不包括最後一個
    cout<<"vec1:"<<endl;  
    //列印vec1和vec2,const_iterator是迭代器,後面會講到
    //當然,也可以用for (int i=0; i<vec1.size(); i++)cout << vec[i];輸出
    //size()是vector的一個成員函式
    for(vector<int>::const_iterator p=vec1.begin();p!=vec1.end(); ++p)
        cout<<*p;
    cout<<"\n"<<"vec2:"<<endl;
    for(vector<char>::const_iterator p1=vec2.begin();p1!=vec2.end(); ++p1)
        cout<<*p1;
    getchar();
    return 0;

  為了幫助理解向量的概念,這裡寫了一個小例子,其中用到了vector的成員函式:begin(),end(),push_back(),assign(),front(),back(),erase(),empty(),at(),size()。
//stl_cpp_8.cpp
#include <iostream>
#include <vector>
using namespace std;
typedef vector<int> INTVECTOR;//自定義型別INTVECTOR
//測試vector容器的功能
void main(void)
{
    //vec1物件初始為空
    INTVECTOR vec1;  
    //vec2物件最初有10個值為6的元素 
    INTVECTOR vec2(10,6); 
    //vec3物件最初有3個值為6的元素,拷貝構造
    INTVECTOR vec3(vec2.begin(),vec2.begin()+3); 
    //宣告一個名為i的雙向迭代器
    INTVECTOR::iterator i;
    //從前向後顯示vec1中的資料
    cout<<"vec1.begin()--vec1.end():"<<endl;
    for (i =vec1.begin(); i !=vec1.end(); ++i)
        cout << *i << " ";
    cout << endl;
    //從前向後顯示vec2中的資料
    cout<<"vec2.begin()--vec2.end():"<<endl;
    for (i =vec2.begin(); i !=vec2.end(); ++i)
        cout << *i << " ";
    cout << endl;
    //從前向後顯示vec3中的資料
    cout<<"vec3.begin()--vec3.end():"<<endl;
    for (i =vec3.begin(); i !=vec3.end(); ++i)
        cout << *i << " ";
    cout << endl;
    //測試新增和插入成員函式,vector不支援從前插入
    vec1.push_back(2);//從後面新增一個成員
    vec1.push_back(4);
    vec1.insert(vec1.begin()+1,5);//在vec1第一個的位置上插入成員5
    //從vec1第一的位置開始插入vec3的所有成員
    vec1.insert(vec1.begin()+1,vec3.begin(),vec3.end());
    cout<<"after push() and insert() now the vec1 is:" <<endl;
    for (i =vec1.begin(); i !=vec1.end(); ++i)
        cout << *i << " ";
    cout << endl;
    //測試賦值成員函式
    vec2.assign(8,1);   // 重新給vec2賦值,8個成員的初始值都為1
    cout<<"vec2.assign(8,1):" <<endl;
    for (i =vec2.begin(); i !=vec2.end(); ++i)
        cout << *i << " ";
    cout << endl;
    //測試引用類函式
    cout<<"vec1.front()="<<vec1.front()<<endl;//vec1第零個成員
    cout<<"vec1.back()="<<vec1.back()<<endl;//vec1的最後一個成員
    cout<<"vec1.at(4)="<<vec1.at(4)<<endl;//vec1的第五個成員
    cout<<"vec1[4]="<<vec1[4]<<endl;
    //測試移出和刪除
    vec1.pop_back();//將最後一個成員移出vec1
    vec1.erase(vec1.begin()+1,vec1.end()-2);//刪除成員
    cout<<"vec1.pop_back() and vec1.erase():" <<endl;
    for (i =vec1.begin(); i !=vec1.end(); ++i)
        cout << *i << " ";
    cout << endl;
    //顯示序列的狀態資訊
    cout<<"vec1.size(): "<<vec1.size()<<endl;//列印成員個數
    cout<<"vec1.empty(): "<<vec1.empty()<<endl;//清空
}

  push_back()是將資料放入vector(向量)或deque(雙端佇列)的標準函式。Insert()是一個與之類似的函式,然而它在所有容器中都可以使用,但是用法更加複雜。end()實際上是取末尾加一,以便讓迴圈正確執行--它返回的指標指向最靠近陣列界限的資料。

  在Java裡面也有向量的概念。Java中的向量是物件的集合。其中,各元素可以不必同類型,元素可以增加和刪除,不能直接加入原始資料型別。

雙端佇列(qeque容器類):#include <deque>
  deque(讀音:deck,意即:double queue)容器類與vector類似,支援隨機訪問和快速插入刪除,它在容器中某一位置上的操作所花費的是線性時間。與vector不同的是,deque還支援從開始端插入資料:
push_front()。此外deque也不支援與vector的capacity()、reserve()類似的操作。

//stl_cpp_9.cpp
#include <iostream>
#include <deque>
using namespace std;
typedef deque<int> INTDEQUE;//有些人很討厭這種定義法,呵呵
//從前向後顯示deque佇列的全部元素
void put_deque(INTDEQUE deque, char *name)
{
    INTDEQUE::iterator pdeque;//仍然使用迭代器輸出
    cout << "The contents of " << name << " : ";
    for(pdeque = deque.begin(); pdeque != deque.end(); pdeque++)
        cout << *pdeque << " ";//注意有 "*"號哦,沒有"*"號的話會報錯
    cout<<endl;
}
//測試deqtor容器的功能
void main(void)
{
    //deq1物件初始為空
    INTDEQUE deq1;   
    //deq2物件最初有10個值為6的元素  
    INTDEQUE deq2(10,6);  
    //deq3物件最初有3個值為6的元素  
    //宣告一個名為i的雙向迭代器變數
    INTDEQUE::iterator i;
    //從前向後顯示deq1中的資料
    put_deque(deq1,"deq1");
    //從前向後顯示deq2中的資料
    put_deque(deq2,"deq2");
    //從deq1序列後面新增兩個元素
    deq1.push_back(2);
    deq1.push_back(4);
    cout<<"deq1.push_back(2) and deq1.push_back(4):"<<endl;
    put_deque(deq1,"deq1");
    //從deq1序列前面新增兩個元素
    deq1.push_front(5);
    deq1.push_front(7);
    cout<<"deq1.push_front(5) and deq1.push_front(7):"<<endl;
    put_deque(deq1,"deq1");
    //在deq1序列中間插入資料
    deq1.insert(deq1.begin()+1,3,9);
    cout<<"deq1.insert(deq1.begin()+1,3,9):"<<endl;
    put_deque(deq1,"deq1");
    //測試引用類函式
    cout<<"deq1.at(4)="<<deq1.at(4)<<endl;
    cout<<"deq1[4]="<<deq1[4]<<endl;
    deq1.at(1)=10;
    deq1[2]=12;
    cout<<"deq1.at(1)=10 and deq1[2]=12 :"<<endl;
    put_deque(deq1,"deq1");
    //從deq1序列的前後各移去一個元素
    deq1.pop_front();
    deq1.pop_back();
    cout<<"deq1.pop_front() and deq1.pop_back():"<<endl;
    put_deque(deq1,"deq1");
    //清除deq1中的第2個元素
    deq1.erase(deq1.begin()+1);
    cout<<"deq1.erase(deq1.begin()+1):"<<endl;
    put_deque(deq1,"deq1");
    //對deq2賦值並顯示
    deq2.assign(8,1);
    cout<<"deq2.assign(8,1):"<<endl;
    put_deque(deq2,"deq2");
}

  上面我們演示了deque如何進行插入刪除等操作,像erase(),assign()是大多數容器都有的操作。關於deque的其他操作請參閱附錄。

表(List容器類):#include <list>
   List又叫連結串列,是一種雙線性列表,只能順序訪問(從前向後或者從後向前),圖2是list的資料組織形式。與前面兩種容器類有一個明顯的區別就是:它不支援隨機訪問。要訪問表中某個下標處的項需要從表頭或表尾處(接近該下標的一端)開始迴圈。而且缺少下標預算符:operator[]。

  同時,list仍然包涵了erase(),begin(),end(),insert(),push_back(),push_front()這些基本函式,下面我們來演示一下list的其他函式功能。

merge():合併兩個排序列表;
splice():拼接兩個列表;
sort():列表的排序;

//stl_cpp_10.cpp
#include <iostream>
#include <string>
#include <list>
using namespace std;
void PrintIt(list<int> n)
{
    for(list<int>::iterator iter=n.begin(); iter!=n.end(); ++iter)
        cout<<*iter<<" ";//用迭代器進行輸出迴圈 
}
void main(void)
{
    list<int> listn1,listn2;
    //給listn1,listn2初始化 
    listn1.push_back(123);
    listn1.push_back(0);
    listn1.push_back(34);
    listn1.push_back(1123);
    //now listn1:123,0,34,1123 
    listn2.push_back(100);
    listn2.push_back(12);
    //now listn2:12,100
    listn1.sort();
    listn2.sort();
    //給listn1和listn2排序
    //now listn1:0,34,123,1123         listn2:12,100 
    PrintIt(listn1);
    cout<<endl;
    PrintIt(listn2);
    listn1.merge(listn2);
    //合併兩個排序列表後,listn1:0,12,34,100,123,1123 
    cout<<endl;
    PrintIt(listn1);
    cin.get();
}

  上面並沒有演示splice()函式的用法,這是一個拗口的函式。用起來有點麻煩。圖3所示是splice函式的功能。將一個列表插入到另一個列表當中。list容器類定義了splice()函式的3個版本: splice(position,list_value);
splice(position,list_value,ptr);
splice(position,list_value,first,last);

  list_value是一個已存在的列表,它將被插入到源列表中,position是一個迭代引數,他當前指向的是要進行拼接的列表中的特定位置。

listn1:123,0,34,1123   listn2:12,100

  執行listn1.splice(find(listn1.begin(),listn1.end(),0),listn2);之後,listn1將變為:123,12,100,34,1123。即把listn2插入到listn1的0這個元素之前。其中,find()函式找到0這個元素在listn1中的位置。值得注意的是,在執行splice之後,list_value將不復存在了。這個例子中是listn2將不再存在。
  第二個版本當中的ptr是一個迭代器引數,執行的結果是把ptr所指向的值直接插入到position當前指向的位置之前.這將只向源列表中插入一個元素。
  第三個版本的first和last也是迭代器引數,並不等於list_value.begin(),list_value.end()。First指的是要插入的列的第一個元素,last指的是要插入的列的最後一個元素。

如果listn1:123,0,34,1123 listn2:12,43,87,100 執行完以下函式之後listn1.splice(find(listn1.begin(),listn1.end(),0),++listn2.begin(),--listn2.end());
listn1:123,43,87,0,34,1123  listn2:12,100

  除了vector,deque,list三種基本順序容器,其他的順序容器還有:slist,bit_vector等等。