《程序設計實習》之【C++標準模板庫STL概述】

STL概述

泛型程序設計

C++語言的核心優勢之一就是便於軟件的重用
C++中有兩個方面體現重用：

• 面向對象的思想：繼承和多態，標準類庫
• 泛型程序設計(generic programming) 的思想： 模板機制，以及標準模板庫 STL

泛型程序設計簡單地說就是使用模板的程序設計法。

將一些常用的數據結構（比如鏈表，數組，二叉樹） 和算法（比如排序，查找）寫成模板，以後則不論數據結構裏放的是什麼對象，算法針對什麼樣的對象，則都不必重新實現數據結構，重新編寫算法。

標準模板庫 (Standard Template Library) 就是一些常用數據結構和算法的模板的集合。
有了STL，不必再寫大多的標準數據結構和算法， 並且可獲得非常高的性能。

STL中的基本概念

• 容器：可容納各種數據類型的通用數據結構，是類模板
• 迭代器：可用於依次存取容器中元素，類似於指針
• 算法：用來操作容器中的元素的函數模板
  
  • sort()來對一個vector中的數據進行排序
  • find()來搜索一個list中的對象

算法本身與他們操作的數據的類型無關，因此他們可以在從簡單數組到高度複雜容器的任何數據結構上使用。

int array[100];

該數組就是容器，而 int *類型的指針變量就可以作爲迭代器，sort 算法可以作用於該容器上，對其進行排序：

容器概述

可以用於存放各種類型的數據（基本類型的變量，對象等）的數據結構，都是類模板，分爲三種：

• 順序容器
  
  • vector，deque，list
• 關聯容器
  
  • set，multiset，map，multimap
• 容器適配器
  
  • stack，queue，priority_queue

對象被插入容器中時，被插入的是對象的一個複製品。許多算法，比如排序，查找，要求對容器中的元素進行比較，有的容器本身就是排序的，所以，放入容器的對象所屬的類，往往還應該重載== 和< 運算符。

順序容器簡介

容器並非排序的，元素的插入位置同元素的值無關，有vector, deque, list三種。

• vector頭文件<vector>

動態數組。元素在內存連續存放。隨機存取任何元素都能在常數時間完成。在尾端增刪元素具有較佳的性能(大部分情況下是常數時間）。

• deque頭文件<deque>

雙向隊列。元素在內存連續存放。隨機存取任何元素都能在常數時 間完成(但次於vector)。在兩端增刪元素具有較佳的性能(大部分情況下是常數時間）。

• list頭文件<list>

雙向鏈表。元素在內存不連續存放。在任何位置增刪元素都能在常數時間完成。不支持隨機存取。

關聯容器簡介

• 元素是排序的
• 插入任何元素，都按相應的排序規則來確定其位置
• 在查找時具有非常好的性能
• 通常以平衡二叉樹的方式實現，插入和檢索的時間都是O(log(N))
• set/multiset頭文件<set>
  set 即集合。set中不允許相同元素，multiset中允許存在相同的元素。
• map/multimap頭文件<map>
  map與set的不同在於map中存放的元素有且僅有兩個成員變量，一個名爲first，另一個名爲second, map根據first值對元素進行從小到大排序， 並可快速地根據first來檢索元素。
  map同multimap的不同在於是否允許相同first值的元素。

容器適配器簡介

• stack頭文件<stack>

棧。是項的有限序列，並滿足序列中被刪除、檢索和修改的項只能是最近插入序列的項（棧頂的項）。後進先出。

• queue頭文件<queue>

隊列。插入只可以在尾部進行， 刪除、檢索和修改只允許從頭部進行。先進先出。

• priority_queue頭文件<queue>
  優先級隊列。最高優先級元素總是第一個出列。

順序容器和關聯容器中都有的成員函數

• begin返回指向容器中第一個元素的迭代器
• end返回指向容器中最後一個元素後面的位置的迭代器
• rbegin返回指向容器中最後一個元素的迭代器
• rend返回指向容器中第一個元素前面的位置的迭代器
• erase從容器中刪除一個或幾個元素
• clear從容器中刪除所有元素

順序容器的常用成員函數

• front返回容器中第一個元素的引用
• back返回容器中最後一個元素的引用
• push_back在容器末尾增加新元素
• pop_back刪除容器末尾的元素
• erase刪除迭代器指向的元素(可能會使該迭代器失效），或刪除一個區間，返回被刪除元素後面的那個元素的迭代器

迭代器

• 用於指向順序容器和關聯容器中的元素
• 迭代器用法和指針類似
• 有const 和非 const兩種
• 通過迭代器可以讀取它指向的元素
• 通過非const迭代器還能修改其指向的元素

定義一個容器類的迭代器的方法可以是：

容器類名::iterator 變量名;

或：

容器類名::const_iterator 變量名;

訪問一個迭代器指向的元素：

* 迭代器變量名

迭代器上可以執行 ++操作, 以使其指向容器中的下一個元素。 如果迭代器到達了容器中的最後一個元素的後面，此時再使用它，就會出錯，類似於使用NULL或未初始化的指針一樣。

迭代器示例

#include <vector>
#include <iostream>
using namespace std;
int main() {
    vector<int> v; //一個存放int元素的數組，一開始裏面沒有元素
    v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4);
    vector<int>::const_iterator i; //常量迭代器
    for( i = v.begin();i != v.end();++i )
        cout << * i << ",";
    cout << endl;
    vector<int>::reverse_iterator r; //反向迭代器
    for( r = v.rbegin();r != v.rend();r++ )
        cout << * r << ",";
    cout << endl;
    vector<int>::iterator j; //非常量迭代器
    for( j = v.begin();j != v.end();j ++ )
        * j = 100;
    for( i = v.begin();i != v.end();i++ )
        cout << * i << ",";

輸出結果：

1,2,3,4
4,3,2,1
100,100,100,100

雙向迭代器

若p和p1都是雙向迭代器，則可對p、p1可進行以下操作：

• ++p, p++使p指向容器中下一個元素
• --p, p--使p指向容器中上一個元素
• * p取p指向的元素
• p = p1賦值
• p == p1 , p!= p1判斷是否相等、不等

隨機訪問迭代器

若p和p1都是隨機訪問迭代器，則可對p、p1可進行以下操作：

• 雙向迭代器的所有操作
• p += i將p向後移動i個元素
• p -= i將p向向前移動i個元素
• p + i值爲: 指向 p 後面的第i個元素的迭代器
• p - i值爲: 指向 p 前面的第i個元素的迭代器
• p[i]值爲: p後面的第i個元素的引用
• p < p1, p <= p1, p > p1, p>= p1

容器	容器上的迭代器類別
vector	隨機訪問
deque	隨機訪問
list	雙向
set/multiset	雙向
map/multimap	雙向
stack	不支持迭代器
queue	不支持迭代器
priority_queue	不支持迭代器

有的算法，例如sort， binary_search需要通過隨機訪問迭代器來訪問容器中的元素，那麼list以及關聯容器就不支持該算法！

vector的迭代器是隨機迭代器，遍歷 vector 可以有以下幾種做法(deque亦然)：

vector<int> v(100);
int i;
for(i = 0; i < v.size() ; i++)
    cout << v[i];     //根據下標隨機訪問
vector<int>::const_iterator ii;
for( ii = v.begin(); ii != v.end ();ii ++ )
    cout << * ii;
for( ii = v.begin(); ii < v.end ();ii ++ )  // 和上面的方法一樣
    cout << * ii;

// 間隔一個輸出
ii = v.begin();
while( ii < v.end()) {
    cout << * ii;
    ii = ii + 2;
}

list 的迭代器是雙向迭代器，正確的遍歷list的方法：

list<int> v;
list<int>::const_iterator ii;
for( ii = v.begin(); ii != v.end (); ++ii )
    cout << * ii;

錯誤的做法：

for( ii = v.begin(); ii < v.end ();ii ++ )
    cout << * ii;  
for(int i = 0;i < v.size() ; i ++)
    cout << v[i];
//雙向迭代器不支持 <,list沒有 [] 成員 函數

算法簡介

• 算法就是一個個函數模板, 大多數在<algorithm> 中定義
• STL中提供能在各種容器中通用的算法，比如查找，排序等
• 算法通過迭代器來操縱容器中的元素。許多算法可以對容器中的一個局部區間進行操作，因此需要兩個參數，一個是起始元素的迭代器， 一個是終止元素的後面一個元素的迭代器。比如，排序和查找。
• 有的算法返回一個迭代器。比如 find() 算法，在容器中查找一個元素，並返回一個指向該元素的迭代器
• 算法可以處理容器，也可以處理普通數組

算法示例：find()

template<class InIt, class T>
InIt find(InIt first, InIt last, const T& val);

• first 和 last 這兩個參數都是容器的迭代器，它們給出了容器中的查找區間起點和終點[first,last)。區間的起點是位於查找範圍之中的，而終點不是。find在[first,last)查找等於val的元素
• 用 == 運算符判斷相等
• 函數返回值是一個迭代器。如果找到，則該迭代器指向被找到的元素。 如果找不到，則該迭代器等於last

#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
int main() {   //find算法示例
    int array[10] = {10,20,30,40};
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    vector<int>::iterator p;
    p = find(v.begin(),v.end(),3);
    if( p != v.end())
        cout << * p << endl; //輸出3
    p = find(v.begin(),v.end(),9);
    if( p == v.end())
        cout << "not found " << endl;
    p = find(v.begin()+1, v.end()-2, 1); //整個容器：[1,2,3,4]， 查找區間：[2,3)
    if( p != v.end())
        cout << * p << endl;
    int * pp = find( array, array+4, 20);//數組名是迭代器
        cout << * pp << endl;
}

輸出：

3
not found
3
20

STL中“大”“小”的概念

• 關聯容器內部的元素是從小到大排序的
• 有些算法要求其操作的區間是從小到大排序的，稱爲“有序區間算法”
  
  • binary_search
• 有些算法會對區間進行從小到大排序，稱爲“排序算法”
  
  • sort
• 還有一些其他算法會用到“大”，“小”的概念

使用STL時，在缺省的情況下，以下三個說法等價：

• x比y小
• 表達式“x

STL中“相等”的概念

• 有時，“x和y相等”等價於“x==y爲真”
  
  • 例：在未排序的區間上進行的算法，如順序查找find
• 有時“x和y相等”等價於“x小於y和y小於x同時爲假”
  
  • 例：有序區間算法，如binary_searc
  • 關聯容器自身的成員函數find

STL中“相等”概念演示

#include <iostream>
#include <algorithm>
using namespace std;
class A {
    int v;
public:
    A(int n):v(n) { }
    bool operator < ( const A & a2) const {
        cout << v << "<" << a2.v << "?" << endl;
        return false;  // 永遠返回false
    }
    bool operator ==(const A & a2) const {
        cout << v << "==" << a2.v << "?" << endl;
        return v == a2.v;
        }

};

int main() {
    A a [] = { A(1),A(2),A(3),A(4),A(5) };
    cout << binary_search(a, a+4, A(9)); //折半查找
    return 0;
}

輸出結果：

3<9?
2<9?
1<9?
9<1?
1

解釋：binary_search中，“x和y相等”等價於“x小於y和y小於x同時爲假”，所以不會用到重載的==函數，依次判斷3，2，1是不是小於9，當判斷到1時，無法再進行二分查找了，又判斷9是不是小於1，因爲重載的<永遠返回false，此時符合binary_search判斷相等的規則，所以返回1。