【STL】适配器（adapters）

定义：将一个class的接口转换为另一个class的接口，使原本因接口不兼容而不能合作的classes，可以一起运作。适配器扮演者轴承、转换器的角色。

分类：

1、容器适配器：改变容器接口。

STL提供两个容器迭代器：queue和stack。它们都是修饰deque后成为另一种风貌的容器。

2、迭代器适配器：改变迭代器接口。

• Insert Iterator：将容器绑定到back_insert_iterator、front_insert_iterator、insert_iterator。它们都是一个类，对它们的赋值操作将转换为对绑定容器的插入操作。为了操作方便，向用户提供的是一个函数，函数中才创建上述类。

以back_inserter为例：

template <class Container>inline back_insert_iterator<Container> back_inserter(Container& x) {  return back_insert_iterator<Container>(x);     // 以容器为参数，创建迭代器适配器}

注意，一般迭代器适配器不会以迭代器作为参数，这里通过传入一个容器创建一个迭代器适配器。

下面是back_insert_iterator类的定义：

template <class Container>class back_insert_iterator {protected:  Container* container; // 注意，这里是一个指向容器的指针public:  typedef output_iterator_tag iterator_category;     // 输出迭代器，只支持自增  typedef void                value_type;  typedef void                difference_type;  typedef void                pointer;  typedef void                reference;   explicit back_insert_iterator(Container& x) : container(&x) {}     // 与容器相绑定  back_insert_iterator<Container>&  operator=(const typename Container::value_type& value) {     container->push_back(value);    return *this;  }  back_insert_iterator<Container>& operator*() { return *this; }  back_insert_iterator<Container>& operator++() { return *this; }  back_insert_iterator<Container>& operator++(int) { return *this; }};

可以看到，迭代器适配器提供了自增和接引用的接口，但是实际的功能被关闭了。上述代码的关键在于，对迭代器适配器的赋值变为了对容器的插入操作。

下面是我自己写的一个类似于上面的迭代器适配器：

#include <iostream>#include <vector> using namespace std; template <class Container>class my_back_insert_iterator {protected:  Container* container;public:  explicit my_back_insert_iterator(Container& x) : container(&x) {}  my_back_insert_iterator<Container>&  operator=(const typename Container::value_type& value) {    container->push_back(value);    return *this;  }}; int main(){    vector<int> vec;    my_back_insert_iterator< vector<int> > back_insert(vec);     back_insert = 1;    back_insert = 2;    back_insert = 3;    back_insert = 4;     vector<int>::iterator iter = vec.begin();    for ( ; iter != vec.end(); ++iter)        cout << *iter << endl;     return 0;}

运行结果：

对迭代器的赋值即是对容器的插入操作。

• Reverse Iterator：使迭代器行进方向逆转。逆向迭代器一般用在容器中，容器都会提供一些接口，如下所示，使它可以和某些算法配合，逆向完成某些操作。

容器中的接口如下：

reverse_iterator rbegin() { return reverse_iterator(end()); }reverse_iterator rend() { return reverse_iterator(begin()); }

在看一下reverse_iterator的构造函数：

Iterator current;     // 保存传入的迭代器....typedef Iterator iterator_type;typedef reverse_iterator<Iterator> self;explicit reverse_iterator(iterator_type x) : current(x) {}     // 构造函数

构造函数的任务就是把传入的迭代器保存在内部的current中。

下面是反向迭代器的关键所在：

reference operator*() const {    Iterator tmp = current;    return *--tmp;     // 先自减，再接引用  }   self& operator++() {    --current;    return *this;  }   self& operator--() {    ++current;    return *this;  }

这里要注意的是接引用操作，先要把迭代器减1，这样才能保证对尾端元素的接引用是正确的。

测试代码如下：

int a[] = {9,5,4,8,3,6,7};reverse_iterator<int*> reverite(a+7); cout << *reverite++ << " ";cout << *reverite++ << " ";cout << *reverite++ << " ";

运行结果：

• IOStream Iterator：将迭代器（istream_iterator或ostream_iterator）绑定到某个iostream对象（cin/cout）上，从而操作这些IO对象。

以绑定标准输出为例，测试代码如下：

int a[] = {9,5,4,8,3,6,7};ostream_iterator<int> outite(cout, " ");     // 输出数组元素时附带输出空格 copy(a, a+7, outite);

运行结果：

上述代码将迭代器适配器绑定到标准输出，并且每输出一个元素，附带输出一个空格符。对迭代器的赋值（operator=）就是对它的输出操作（operator<<）。源代码如下：

template <class T>class ostream_iterator {protected:  ostream* stream;     // 绑定的标准输出  const char* string;  // 分隔符public:  typedef output_iterator_tag iterator_category;  typedef void                value_type;  typedef void                difference_type;  typedef void                pointer;  typedef void                reference;   ostream_iterator(ostream& s) : stream(&s), string(0) {}  ostream_iterator(ostream& s, const char* c) : stream(&s), string(c)  {}  ostream_iterator<T>& operator=(const T& value) {     *stream << value;               // 关键点    if (string) *stream << string;  // 输出间隔符    return *this;  }// 以下三个操作都返回自己  ostream_iterator<T>& operator*() { return *this; }  ostream_iterator<T>& operator++() { return *this; }   ostream_iterator<T>& operator++(int) { return *this; } };

注意最后三个操作都只是本身，这样做的目的是可以配合copy()等算法：

*result = *first;

result就是该迭代器，对它接引用然后进行赋值操作将调用上面的operator=函数，使得copy()算法能够把一段范围内的元素输出到标准输出。这也正是泛型算法的精妙之处：算法只负责做固定工作，至于具体如何实现，由各个迭代器来完成。

3、函数适配器：改变仿函数/函数接口，用于特化和扩展一元和二元函数对象，使其能够适应STL算法的参 

      数接口。标准库将它分两类：

• 绑定器（bind1st/bind2nd）：将一个操作数绑定到给定值而将二元函数对象转换为一元函数对象。
• 求反器：将谓词函数对象的真值求反。

以count_if为例，应用程序调用如下代码：

// 计算容器中小于等于3的元素个数cout << count_if(vec.begin(), vec.end(), bind2nd(less_equal<int>(), 3));

则会调用如下函数：

template <class InputIterator, class Predicate, class Size>void count_if(InputIterator first, InputIterator last, Predicate pred,              Size& n) {  for ( ; first != last; ++first)    if (pred(*first))       /* 对每个元素调用仿函数 */      ++n;                  /* 满足条件则累加 */}

下面看看pred，也就是bind2nd的源代码：

template <class Operation> class binder2nd  : public unary_function<typename Operation::first_argument_type,                          typename Operation::result_type> {protected:  Operation op;  typename Operation::second_argument_type value;public:  binder2nd(const Operation& x,   // 仿函数            const typename Operation::second_argument_type& y)  // 绑定的第二个数      : op(x), value(y) {}  typename Operation::result_type  operator()(const typename Operation::first_argument_type& x) const {    return op(x, value);  // 关键点  }};

代码一目了然。需要注意一点，此函数适配器必须要继承自unary_function对象，满足可配接性。解释一下可配接性。less_equal类继承自binary_function，便有了内部嵌套类型second_argument_type，而这个类型正好需要用在binder2nd中，以保存（绑定）某个参数。这样，less_equal就变为了可配接的。如果还有其它的适配器需要继续作用在binder2nd上，那么binder2nd也需要提供这样的嵌套类型，使它变为可配接的。这在另一篇文章“<ch07>仿函数”中也有所说明。

总结：

纵观整个适配器系统，基本上都是把某个对象或指向对象的指针封装在一个适配器类中，对适配器的操作最终都会传递到对所包含对象的操作上来。

参考：

《C++ primer》 P453.

《STL源码剖析》 第八章。