C++語言學習之STL 的組成

STL有三大核心部分：容器（Container）、算法（Algorithms）、迭代器（Iterator），容器適配器（container adaptor），函數對象(functor)，除此之外還有STL其他標準組件。通俗的講：

容器：裝東西的東西，裝水的杯子，裝咸水的大海，裝人的教室……STL里的容器是可容納一些數據的模板類。

算法：就是往杯子里倒水，往大海里排污，從教室里攆人……STL里的算法，就是處理容器里面數據的方法、操作。

迭代器：往杯子里倒水的水壺，排污的管道，攆人的那個物業管理人員……STL里的迭代器：遍歷容器中數據的對象。對存儲于容器中的數據進行處理時，迭代器能從一個成員移向另一個成員。他能按預先定義的順序在某些容器中的成員間移動。對普通的一維數組、向量、雙端隊列和列表來說，迭代器是一種指針。

下面讓我們來看看專家是怎么說的：

容器（container）：容器是數據在內存中組織的方法，例如，數組、堆棧、隊列、鏈表或二叉樹（不過這些都不是STL標準容器）。STL中的容器是一種存儲T（Template）類型值的有限集合的數據結構,容器的內部實現一般是類。這些值可以是對象本身，如果數據類型T代表的是Class的話。

算法（algorithm）：算法是應用在容器上以各種方法處理其內容的行為或功能。例如，有對容器內容排序、復制、檢索和合并的算法。在STL中，算法是由模板函數表現的。這些函數不是容器類的成員函數。相反，它們是獨立的函數。令人吃驚的特點之一就是其算法如此通用。不僅可以將其用于STL容器，而且可以用于普通的C＋＋數組或任何其他應用程序指定的容器。

迭代器(iterator)：一旦選定一種容器類型和數據行為(算法)，那么剩下唯一要他做的就是用迭代器使其相互作用。可以把達代器看作一個指向容器中元素的普通指針。可以如遞增一個指針那樣遞增迭代器，使其依次指向容器中每一個后繼的元素。迭代器是STL的一個關鍵部分，因為它將算法和容器連在一起。

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

1.       容器

STL中的容器有隊列容器和關聯容器，容器適配器（congtainer adapters：stack,queue，priority queue），位集（bit_set），串包(string_package)等等。
　　在本文中，我將介紹list,vector，deque等隊列容器，和set和multisets,map和multimaps等關聯容器，一共7種基本容器類。
　　隊列容器（順序容器）：隊列容器按照線性排列來存儲T類型值的集合，隊列的每個成員都有自己的特有的位置。順序容器有向量類型、雙端隊列類型、列表類型三種。

u     基本容器——向量

向量（vector容器類）：＃include <vector>，vector是一種動態數組，是基本數組的類模板。其內部定義了很多基本操作。既然這是一個類，那么它就會有自己的構造函數。vector 類中定義了4中種構造函數：

·  默認構造函數，構造一個初始長度為0的空向量，如：vector<int> v1;

·  帶有單個整形參數的構造函數，此參數描述了向量的初始大小。這個構造函數還有一個可選的參數，這是一個類型為T的實例，描述了各個向量種各成員的初始值；如：vector<int> v2(n,0); 如果預先定義了：n,他的成員值都被初始化為0；

·  復制構造函數，構造一個新的向量，作為已存在的向量的完全復制，如：vector<int> v3(v2);

·  帶兩個常量參數的構造函數，產生初始值為一個區間的向量。區間由一個半開區間[first,last) 來指定。如：vector<int> v4(first,last）

下面一個例子用的是第四種構造方法，其它的方法讀者可以自己試試。

//程序：初始化演示
#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()
{
    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;
    cout<<'/n';
    return 0;
}

 

為了幫助理解向量的概念，這里寫了一個小例子，其中用到了vector的成員函數：begin()，end()，push_back()，assign()，front()，back()，erase()，empty()，at()，size()。

 

#include <iostream>
#include <vector>
using namespace std;

typedef vector<int> INTVECTOR;//自定義類型INTVECTOR
//測試vector容器的功能

int main()
{
    //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中的向量是對象的集合。其中，各元素可以不必同類型，元素可以增加和刪除，不能直接加入原始數據類型。

 

u     雙端隊列（qeque容器類）：

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

#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容器的功能
int main()
{
    //deq1對象初始為空
    INTDEQUE deq1;  
    //deq2對象最初有10個值為6的元素  
    INTDEQUE deq2(10,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的其他操作請參閱其他書籍。

u     表（List容器類）

　List（#include<list>）又叫鏈表，是一種雙線性列表，只能順序訪問（從前向后或者從后向前），圖2是list的數據組織形式。與前面兩種容器類有一個明顯的區別就是：它不支持隨機訪問。要訪問表中某個下標處的項需要從表頭或表尾處（接近該下標的一端）開始循環。而且缺少下標預算符：operator[]。

 

圖2
　　同時，list仍然包涵了erase(),begin(),end(),insert(),push_back(),push_front()這些基本函數，下面我們來演示一下list的其他函數功能。merge()：合并兩個排序列表；splice()：拼接兩個列表；sort()：列表的排序。

#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<<" ";//用迭代器進行輸出循環
}

int main()
{
    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);
}

 

上面并沒有演示splice()函數的用法，這是一個拗口的函數。用起來有點麻煩。圖3所示是splice函數的功能。將一個列表插入到另一個列表當中。list容器類定義了splice()函數的3個版本：

splice(position,list_value);

splice(position,list_value,ptr);

splice(position,list_value,first,last);

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

                                  圖3

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等等。

u     集和多集（set 和multiset 容器類）：

一個集合（#include<set>）是一個容器，它其中所包含的元素的值是唯一的。這在收集一個數據的具體值的時候是有用的。集合中的元素按一定的順序排列，并被作為集合中的實例。如果你需要一個鍵/值對（pair）來存儲數據，map（也是一個關聯容器，后面將馬上要講到）是一個更好的選擇。一個集合通過一個鏈表來組織，在插入操作和刪除操作上比向量（vector）快，但查找或添加末尾的元素時會有些慢。

在集中，所有的成員都是排列好的。如果先后往一個集中插入：12，2，3，123，5，65 　　則輸出該集時為：2，3，5，12，65，123

集和多集的區別是：set支持唯一鍵值，set中的值都是特定的，而且只出現一次；而multiset中可以出現副本鍵，同一值可以出現多次。

Set和multiset的模板參數：

template<class key, class compare, class Allocator=allocator>

第一個參數key是所存儲的鍵的類型，第二個參數是為排序值而定義的比較函數的類型，第三個參數是被實現的存儲分配符的類型。在有些編譯器的具體實現中，第三個參數可以省略。第二個參數使用了合適形式的迭代器為鍵定義了特定的關系操作符，并用來在容器中遍歷值時建立順序。集的迭代器是雙向，同時也是常量的，所以迭代器在使用的時候不能修改元素的值。

Set定義了三個構造函數：
默認構造函數：

explicit set(const Compare&=compare());

如：set<int,less<int> > set1;

less<int>是一個標準類，用于形成降序排列函數對象。升序排列是用greater<int>。通過指定某一預先定義的區間來初始化set對象的構造函數：

template<class InputIterator> set(InputIterator, InputIterator,/ const Compare&=compare());

如：set<int ,less<int> >set2(vector1.begin(),vector1.end());

復制構造函數：

set（const set<Key,Compare&>）;

如：set<int ,less<int> >set3(set2);

下面我們來看一個簡單的集和多集的插入例程：

#include <iostream>
#include <set>
using namespace std;

int main()
{
    set<int> set1;
    for(int i=0; i<10; ++i)
        set1.insert(i);
    for(set<int>::iterator p=set1.begin();p!=set1.end();++p)
        cout<<*p<<"";
    if(set1.insert(3).second)//把3插入到set1中
//插入成功則set1.insert(3).second返回1，否則返回0
//此例中，集中已經有3這個元素了，所以插入將失敗
        cout<<"set insert success";
    else
        cout<<"set insert failed";
    int a[] = {4, 1, 1, 1, 1, 1, 0, 5, 1, 0};
    multiset<int> A;
    A.insert(set1.begin(),set1.end());
    A.insert(a,a+10);
    cout<<endl;
    for(multiset<int>::iterator p=A.begin();p!=A.end();++p)
    cout<<*p<<" ";
    return 0;
}

 

u     映射和多重映射（map 和multimap）

映射和多重映射(#include<map>)基于某一類型Key的鍵集的存在，提供對T類型的數據進行快速和高效的檢索。對map而言，鍵只是指存儲在容器中的某一成員。Map不支持副本鍵，multimap支持副本鍵。Map和multimap對象包涵了鍵和各個鍵有關的值，鍵和值的數據類型是不相同的，這與set不同。set中的key和value是Key類型的，而map中的key和value是一個pair結構中的兩個分量。Map支持下表運算符operator[],用訪問普通數組的方式訪問map，不過下標為map的鍵。在multimap中一個鍵可以對應多個不同的值。

下面的例程說明了map中鍵與值的關系。

#include <iostream>

#include <map>

using namespace std;

 

int main()

{

    map<char,int,less<char> > map1;

    map<char,int,less<char> >::iterator mapIter;

    //char 是鍵的類型，int是值的類型

    //下面是初始化，與數組類似

    //也可以用map1.insert(map<char,int,less<char> >::value_type(''c'',3));

    map1['c']=3;

    map1['d']=4;

    map1['a']=1;

    map1['b']=2;

    for(mapIter=map1.begin();mapIter!=map1.end();++mapIter)

        cout<<" "<<(*mapIter).first<<": "<<(*mapIter).second;

    //first對應定義中的char鍵，second對應定義中的int值  

    //檢索對應于d鍵的值是這樣做的：

    map<char,int,less<char> >::const_iterator ptr;

    ptr=map1.find('d');

    cout<<'/n'<<" "<<(*ptr).first<<" 鍵對應于值："<<(*ptr).second;

    return 0;

}

　　從以上例程中，我們可以看到map對象的行為和一般數組的行為類似。Map允許兩個或多個值使用比較操作符。下面我們再看看multimap:

#include <iostream>
#include <map>
#include <string>
using namespace std;

int main()
{
    multimap<string,string,less<string> >mulmap;
    multimap<string,string,less<string> >::iterator p;
    //初始化多重映射mulmap:
    typedef multimap<string,string,less<string> >::value_type vt;
    typedef string s;
    mulmap.insert(vt(s("Tom "),s("is a student")));
    mulmap.insert(vt(s("Tom "),s("is a boy")));
    mulmap.insert(vt(s("Tom "),s("is a bad boy of blue!")));
    mulmap.insert(vt(s("Jerry "),s("is a student")));
    mulmap.insert(vt(s("Jerry "),s("is a beatutiful girl")));
    mulmap.insert(vt(s("DJ "),s("is a student")));
    //輸出初始化以后的多重映射mulmap:
    for(p=mulmap.begin();p!=mulmap.end();++p)
        cout<<(*p).first<<(*p).second<<endl;
    //檢索并輸出Jerry鍵所對應的所有的值
    cout<<"find Jerry :"<<endl;
    p=mulmap.find(s("Jerry "));
    while((*p).first=="Jerry ")
    {
        cout<<(*p).first<<(*p).second<<endl;
        ++p;
    }   
    return 0;
}

 

在map中是不允許一個鍵對應多個值的，在multimap中，不支持operator[],也就是說不支持map中允許的下標操作。

2.       算法（algorithm）：

#inlcude <algorithm>

STL中算法的大部分都不作為某些特定容器類的成員函數，他們是泛型的，每個算法都有處理大量不同容器類中數據的使用。值得注意的是，STL中的算法大多有多種版本，用戶可以依照具體的情況選擇合適版本。中在STL的泛型算法中有4類基本的算法：

變序型隊列算法：可以改變容器內的數據；

非變序型隊列算法：處理容器內的數據而不改變他們；

排序值算法：包涵對容器中的值進行排序和合并的算法，還有二叉搜索算法、通用數值算法。（注：STL的算法并不只是針對STL容器，對一般容器也是適用的。）

變序型隊列算法：又叫可修改的序列算法。這類算法有復制（copy）算法、交換（swap）算法、替代（replace）算法、刪除（clear）算法，移動（remove）算法、翻轉（reverse）算法等等。這些算法可以改變容器中的數據（數據值和值在容器中的位置）。

下面介紹2個比較常用的算法reverse()和copy()。

#include <iostream>
#include <algorithm>
#include <iterator>
//下面用到了輸出迭代器ostream_iterator
using namespace std;

int main()
{
    int arr[6]={1,12,3,2,1215,90};
    int arr1[7];
    int arr2[6]={2,5,6,9,0,-56};
    copy(arr,(arr+6),arr1);//將數組aar復制到arr1
    cout<<"arr[6] copy to arr1[7],now arr1: "<<endl;
    for(int i=0;i<7;i++)
        cout<<" "<<arr1[i];
    reverse(arr,arr+6);//將排好序的arr翻轉
    cout<<'/n'<<"arr reversed ,now arr:"<<endl;
    copy(arr,arr+6,ostream_iterator<int>(cout, " "));//復制到輸出迭代器
    swap_ranges(arr,arr+6,arr2);//交換arr和arr2序列
    cout<<'/n'<<"arr swaped to arr2,now arr:"<<endl;
    copy(arr,arr+6,ostream_iterator<int>(cout, " "));
    cout<<'/n'<<"arr2:"<<endl;
    copy(arr2,arr2+6,ostream_iterator<int>(cout, " "));
    return 0;
}

 

revese()的功能是將一個容器內的數據順序翻轉過來，它的原型是：

template<class Bidirectional>

void reverse(Bidirectional first, Bidirectional last);

將first和last之間的元素翻轉過來，上例中你也可以只將arr中的一部分進行翻轉：

reverse(arr+3,arr+6); 這也是有效的。First和last需要指定一個操作區間。

Copy()是要將一個容器內的數據復制到另一個容器內，它的原型是：

  Template<class InputIterator ，class OutputIterator>

  OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result);

它把[first,last－1]內的隊列成員復制到區間[result,result+(last-first)-1]中。泛型交換算法：

 

Swap()操作的是單值交換，它的原型是：

template<class T>

void swap(T& a,T& b);

 

swap_ranges()操作的是兩個相等大小區間中的值，它的原型是：

  template<class ForwardIterator1, class ForwardIterator2>

  ForwardIterator2swap_ranges(ForwardIterator1 first1,ForwardIterator1 last1, ForwardIterator1 first2);

交換區間[first1,last1-1]和[first2, first2+(last1-first1)-1]之間的值，并假設這兩個區間是不重疊的。

非變序型隊列算法，又叫不可修改的序列算法。這一類算法操作不影響其操作的容器的內容，包括搜索隊列成員算法，等價性檢查算法，計算隊列成員個數的算法。我將用下面的例子介紹其中的find(),search(),count()：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
    int a[10]={12,31,5,2,23,121,0,89,34,66};
    vector<int> v1(a,a+10);
    vector<int>::iterator result1,result2;//result1和result2是隨機訪問迭代器
    result1=find(v1.begin(),v1.end(),2);
    //在v1中找到2，result1指向v1中的2
    result2=find(v1.begin(),v1.end(),8);
    //在v1中沒有找到8，result2指向的是v1.end()
    cout<<result1-v1.begin()<<endl; //3－0＝3或4－1＝3，屏幕結果是3
    cout<<result2-v1.end()<<endl;   
    int b[9]={5,2,23,54,5,5,5,2,2};
    vector<int> v2(a+2,a+8);
    vector<int> v3(b,b+4);
    result1=search(v1.begin(),v1.end(),v2.begin(),v2.end());
    cout<<*result1<<endl;
    //在v1中找到了序列v2，result1指向v2在v1中開始的位置
     result1=search(v1.begin(),v1.end(),v3.begin(),v3.end());
     cout<<*(result1-1)<<endl;
    //在v1中沒有找到序列v3，result指向v1.end(),屏幕打印出v1的最后一個元素66   
     vector<int> v4(b,b+9);
     int i=count(v4.begin(),v4.end(),5);
     int j=count(v4.begin(),v4.end(),2);
     cout<<"there are "<<i<<" members in v4 equel to 5"<<endl;
     cout<<"there are "<<j<<" members in v4 equel to 2"<<endl;
     //計算v4中有多少個成員等于 5,2
     return 0;        
}

 

find()的原型是：

template<class InputIterator，class EqualityComparable>

InputIterator find(InputIterator first, InputIterator last, const EqualityComparable& value);

其功能是在序列[first,last-1]中查找value值，如果找到，就返回一個指向value在序列中第一次出現的迭代，如果沒有找到，就返回一個指向last的迭代（last并不屬于序列）。

search()的原型是：

template <class ForwardIterator1, class ForwardIterator2>

ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,                        ForwardIterator2 first2, ForwardIterator2 last2);

其功能是在源序列[first1,last1-1]查找目標序列[first2，last2-1]如果查找成功，就返回一個指向源序列中目標序列出現的首位置的迭代。查找失敗則返回一個指向last的迭代。

Count()的原型是：

template <class InputIterator, class EqualityComparable>

iterator_traits<InputIterator>::difference_type count(InputIterator first,

InputIterator last, const EqualityComparable& value);

其功能是在序列[first,last-1]中查找出等于value的成員，返回等于value得成員的個數。

排序算法（sort algorithm）：這一類算法很多，功能強大同時也相對復雜一些。這些算法依賴的是關系運算。在這里我只介紹其中比較簡單的幾種排序算法：sort(),merge(),includes()

#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    int a[10]={12,0,5,3,6,8,9,34,32,18};
    int b[5]={5,3,6,8,9};
    int d[15];
    sort(a,a+10);
    for(int i=0;i<10;i++)
      cout<<" "<<a[i];
    sort(b,b+5);
    if(includes(a,a+10,b,b+5))
       cout<<'/n'<<"sorted b members are included in a."<<endl;
    else
       cout<<"sorted a dosn`t contain sorted b!";
    merge(a,a+10,b,b+5,d);
    for(int j=0;j<15;j++)
       cout<<" "<<d[j];
    return 0;
}

 

sort()的原型是：

template <class RandomAccessIterator>

void sort(RandomAccessIterator first, RandomAccessIterator last);

功能是對[first,last-1]區間內的元素進行排序操作。與之類似的操作還有：partial_sort(), stable_sort()，partial_sort_copy()等等。

merge()的原型是：

template <class InputIterator1, class InputIterator2, class OutputIterator>

OutputIterator merge(InputIterator1 first1, InputIterator1 last1,InputIterator2  first2, InputIterator2 st2,OutputIterator result);

將有序區間[first1,last1-1]和[first2,last2-1]合并到[result, result + (last1 - first1) + (last2 - first2)-1]區間內。

Includes()的原型是：

template <class InputIterator1, class InputIterator2>

bool includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);

其功能是檢查有序區間[first2,last2-1]內元素是否都在[first1,last1-1]區間內，返回一個bool值。

通用數值算法（generalized numeric algorithms）：這一類算法還不多，涉及到專業領域中有用的算術操作，獨立包涵于頭文件<numeric>中。
　　STL中的算法大都有多種版本，常見的版本有以下4中：

默認版本，假設給出了特定操作符；

一般版本，使用了成員提供的操作符；

復制版本，對原隊列的副本進行操作，常帶有 _copy 后綴；

謂詞版本，只應用于滿足給定謂詞的隊列成員，常帶有 _if 后綴；

 

以上我們學習了STL容器和算法的概念，以及一些簡單的STL容器和算法。在使用算法處理容器內的數據時，需要從一個數據成員移向另一個數據成員，迭代器恰好實現了這一功能。下面我們來學習STL迭代器 。

3.       迭代器（itertor）：

#include<iterator>

迭代器實際上是一種泛化指針，如果一個迭代器指向了容器中的某一成員，那么迭代器將可以通過自增自減來遍歷容器中的所有成員。迭代器是聯系容器和算法的媒介，是算法操作容器的接口。在運用算法操作容器的時候，我們常常在不知不覺中已經使用了迭代器。
STL中定義了6種迭代器：

輸入迭代器，在容器的連續區間內向前移動，可以讀取容器內任意值；

輸出迭代器，把值寫進它所指向的隊列成員中；

前向迭代器，讀取隊列中的值，并可以向前移動到下一位置（++p,p++）；

雙向迭代器，讀取隊列中的值，并可以向前向后遍歷容器；

隨機訪問迭代器, vector<T>::iterator，list<T>::iterator等都是這種迭代器 ；

流迭代器，可以直接輸出、輸入流中的值；

實際上，在前面的例子中，我們不停的在用迭代器。下面我們用幾個例子來幫助理解這些迭代器的用法。
下面的例子用到了輸入輸出迭代器：

#include <iostream>
#include <fstream>
#include <iterator>
#include <vector>
#include <string>
using namespace std;

int main()
{
    vector<string> v1;
    ifstream file("Text1.txt");
    if(file.fail())
    {
        cout<<"open file Text1.txt failed"<<endl;
        return 1;
    }   
    copy(istream_iterator<string>(file),istream_iterator<string>(),inserter(v1,v1.begin()));
    copy(v1.begin(),v1.end(),ostream_iterator<string>(cout," "));
    cout<<endl;
    return 0;
}

 

這里用到了輸入迭代器istream_iterator，輸出迭代器ostream_iterator。程序完成了將一個文件輸出到屏幕的功能，先將文件讀入，然后通過輸入迭代器把文件內容復制到類型為字符串的向量容器內，最后由輸出迭代器輸出。Inserter是一個輸入迭代器的一個函數(迭代器適配器)，它的使用方法是：

inserter (container ,pos);

container是將要用來存入數據的容器，pos是容器存入數據的開始位置。上例中，是把文件內容存入（copy()）到向量v1中。

4.       STL的其他標準組件

函數對象（functor或者funtion objects）

#include<functional>

函數對象又稱之為仿函數。函數對象將函數封裝在一個對象中，使得它可作為參數傳遞給合適的STL算法，從而使算法的功能得以擴展。可以把它當作函數來使用。用戶也可以定義自己的函數對象。下面讓我們來定義一個自己的函數對象.

#include <iostream>
using namespace std;

struct int_max{
int operator()(int x,int y){return x>y?x:y; }
};//operator() 重載了"（）"， (int x,int y)是參數列表

int main()
{
    cout<<int_max()(3,4)<<endl;
    return 0;
}

 

這里的int_max（）就是一個函數對象，struct關鍵字也可以用class來代替，只不過struct默認情況下是公有訪問權限，而class定義的是默認私有訪問權限。下面我們來定義一個STL風格的函數對象：

#include <iostream>
#include <vector>
using namespace std;

struct adder : public unary_function<double, void>
{
    adder() : sum(0) {}
    double sum;
    void operator()(double x) { sum += x; }
};

int main()
{  
    double a[5]={0.5644,1.1,6.6,8.8,9.9};
    vector<double> V(a,a+5);
    adder result = for_each(V.begin(), V.end(), adder());
    cout << "The sum is " << result.sum << endl;
    return 0;
}

 

在這里，我們定義了一個函數對象adder()，這也是一個類，它的基類是unary_function函數對象。unary_function是一個空基類，不包涵任何操作或變量。只是一種格式說明，它有兩個參數，第一個參數是函數對象的使用數據類型，第二個參數是它的返回類型。基于它所定義的函數對象是一元函數對象。（注：用關鍵字struct或者class定義的類型實際上都是"類"）

STL內定義了各種函數對象，否定器、約束器、一元謂詞、二元謂詞都是常用的函數對象。函數對象對于編程來說很重要，因為他如同對象類型的抽象一樣作用于操作。

適配器（adapter）

適配器是用來修改其他組件接口的STL組件，是帶有一個參數的類模板（這個參數是操作的值的數據類型）。STL定義了3種形式的適配器：容器適配器，迭代器適配器，函數適配器。

容器適配器：包括棧（stack）、隊列(queue)、優先(priority_queue)。使用容器適配器，stack就可以被實現為基本容器類型（vector,dequeue,list）的適配。可以把stack看作是某種特殊的vctor、deque或者list容器，只是其操作仍然受到stack本身屬性的限制。queue和priority_queue與之類似。容器適配器的接口更為簡單，只是受限比一般容器要多；

迭代器適配器：修改為某些基本容器定義的迭代器的接口的一種STL組件。反向迭代器和插入迭代器都屬于迭代器適配器，迭代器適配器擴展了迭代器的功能；

函數適配器：通過轉換或者修改其他函數對象使其功能得到擴展。這一類適配器有否定器（相當于"非"操作）、幫定器、函數指針適配器。