定义：将一个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源码剖析》 第八章。
- 前言
- 顺序容器 — heap
- 关联容器 — 红黑树
- 关联容器 — set
- 关联容器 — map
- 关联容器 — hashtable
- 关联容器 — hash_set
- 关联容器 — hash_map
- 算法 — copy
- 顺序容器 — stack
- 顺序容器 — queue
- 顺序容器 — priority_queue
- 顺序容器 — slist
- construct()和destroy()
- 空间配置器
- 函数适配器
- 迭代器以及“特性萃取机”iterator_traits
- 算法 — partial_sort
- 算法 — sort
- 仿函数
- 适配器（adapters）
- C++简易vector
- C++简易list
- STL算法实现
- C++模板Queue