1. 容器適配器

• 順序容器適配器

• 通用類型

• 通用操作（初始化+關系運算）
  • 默認基礎容器類型初始化
    基本初始化方式：
    • 空適配器：A a;
    • 復制容器c元素的適配器：A a(c);
      例如：

    stack<int> oTestStk1;// 等同于stack<int,deque<int> > oTestStk1;
    stack<int> oTestStk2(dep);// 等同于stack<int,deque<int> > oTestStk2(dep);

• 覆蓋基礎容器類型初始化
  覆蓋上面基礎容器類型，例如：利用vector<int>覆蓋stack默認的deque<int>

    stack<int,vector<int> > oTestStk1;
    stack<int,vector<int> > oTestStk2(vec);

• 關系運算
  支持關系運算：==,!=,>,>=,<,<=
  使用關系運算要求元素支持==和<兩個運算符。

• 棧適配器

• stack的基本操作
  stack是后進先出LIFO

雖然stack的默認基礎容器是deque,但是，不再支持deque獨有的方法。例如，stack不再支持deque的push_back方法，取而代之的是push方法。

• 隊列適配器
• queue的基本操作
  queue是后進先出FIFO

雖然queue的默認基礎容器是deque,但是，不再支持deque獨有的方法。例如，queue不再支持deque的push_back方法，取而代之的是push方法。

2. 函數對象適配器

函數對象的適配器，用于特化和擴展一元或者二元函數對象，主要分為兩類：

1. 綁定器(binder)：給二元函數對象綁定一個常量，轉化成一元函數對象。包括bind1st和bind2nd。

2. 取反器(negator)：將謂詞函數對象結果取反。包括not1和not2。

總結

• 綁定STL的仿函數

#include <iostream>
#include <functional>
#include <algorithm>
using namespace std;
int main () {
    int numbers[] = {1,2,3,4,5,6};
    int cnt = count_if (numbers, numbers+6, bind1st(less<int>(),4) );
    cout << "There are  elements that are > 4:" << cnt << "\n";
    cnt = count_if (numbers, numbers+6, bind2nd(less<int>(),4) );
    cout << "There are  elements that are < 4:" << cnt << "\n";
    nt = count_if (numbers, numbers+6, bind2nd(equal_to<int>(),4) );
    cout << "There are  elements that are = 4:" << cnt << "\n";
    return 0;
}

• 綁定自定義的仿函數

#include <iostream>
#include <functional>
#include <algorithm>
using namespace std;
class Functor:public binary_function<int,int,void>{
public:
    void operator()(int first, int secend)const{
        cout << "first:" << first << " " << "secend:" << secend << endl;
        return;
    }
};
int main () {
    // binder1st<Functor> fctor  = bind1st(Functor(),1);
    // fctor(2);
    bind1st(Functor(),1)(2);
    bind2nd(Functor(),1)(2);
    return 0;
}

3. 迭代器適配器

分類

• 流迭代器適配器
• 輸出流迭代器適配器ostreambuf_iterator
• 輸入流迭代器適配器istreambuf_iterator
• 逆向迭代器適配器reverse_iterator
• 插入迭代器適配器
• 插入迭代器適配器insert_iterator
• 前向插入迭代器適配器front_insert_iterator
• 后向插入迭代器適配器back_insert_iterator

1. 流迭代器適配器

1.2 輸出流迭代器適配器ostreambuf_iterator

• ostreambuf_iterator.cpp

#include <iostream>
#include <iterator>
#include <vector>
using namespace std;
int main(){
    int arr[] = {1,2,3,4,5,6};
    ostream_iterator<int> os_it(cout," ");
    copy(arr,arr+6,os_it);

    vector<int> vec(arr,arr+6);
    ostream_iterator<int> os_it2(cout," ");
    copy(vec.begin(),vec.end(),os_it2);
}

1.2 輸入流迭代器適配器istream_iterator

• istream_iterator.cpp

#include <iostream>
#include <vector>
#include <iterator>
using namespace std;
int main(){
    istream_iterator<int> eos;
    istream_iterator<int> is_it(cin);
    ostream_iterator<int> os_it(cout,",");
    
    int arr[10];
    copy(is_it,eos,arr);
    copy(arr,arr+10,os_it);
    cout << endl;
    
    cin.clear();
    vector<int> vec;    
    copy(istream_iterator<int>(cin),eos,back_inserter(vec));
    copy(vec.begin(),vec.end(),os_it);
}

2. 逆向迭代器適配器reverse_iterator

逆向迭代器適配器:template <class Iterator> class reverse_iterator;

• reverse_iterator.cpp

#include <iostream>
#include <vector>
#include <iterator>
using namespace std;
int main(){
    int arr[] = {1,2,3,4,5,6};
    vector<int> vec(arr,arr+6);
    copy(vec.begin(),vec.end(),ostream_iterator<int>(cout,","));
    cout << endl;
    copy(
        reverse_iterator<vector<int>::iterator>(vec.end()),
        reverse_iterator<vector<int>::iterator>(vec.begin()),
        ostream_iterator<int>(cout,","));
    cout << endl;
}

3. 插入迭代器適配器

|函數|作用|
|:-|
|insert_iterator<Container> inserter (Container& x, Iterator it)|創(chuàng)建插入迭代器,必須是包含成員函數insert()的容器，比如：順序容器(vector、list與deque)、關聯(lián)容器(map與set)|
|front_insert_iterator<Container> front_inserter (Container& x)|創(chuàng)建前向插入迭代器，必須是包含成員函數push_front()的容器，比如：list與deque|
|back_insert_iterator<Container> back_inserter (Container& x)|創(chuàng)建后向插入迭代器，必須是包含成員函數push_back()的容器，比如：vector、list與deque|

• inserter.cpp

#include <iostream>
#include <vector>
#include <iterator>
using namespace std;
int main(){
    int arr[] = {1,2,3,4,5,6};
    vector<int> vec(arr,arr+6);
    vector<int>:: iterator it = vec.begin();
    advance(it,3);
    copy(arr,arr+3,it);
    copy(vec.begin(),vec.end(),ostream_iterator<int>(cout,","));
    cout << endl;
    copy(arr+3,arr+6,inserter(vec,it));
    copy(vec.begin(),vec.end(),ostream_iterator<int>(cout,","));
}

• front_inserter.cpp

#include <iostream>
#include <list>
#include <iterator>
using namespace std;
int main(){
    int arr[] = {1,2,3,4,5,7};
    list<int> vec(5);
    ostream_iterator<int> os_it(cout,",");
    copy(arr,arr+3,front_inserter(vec));
    copy(vec.begin(),vec.end(),os_it);
}

• back_inserter.cpp

#include <iostream>
#include <list>
#include <iterator>
using namespace std;
int main(){
    int arr[] = {1,2,3,4,5,7};
    list<int> vec(5);
    ostream_iterator<int> os_it(cout,",");

    copy(arr+3,arr+6,back_inserter(vec));
    copy(vec.begin(),vec.end(),os_it);
}