适配器(adapters)
最后更新于:2022-04-01 19:54:55
定义:将一个class的接口转换为另一个class的接口,使原本因接口不兼容而不能合作的classes,可以一起运作。适配器扮演者轴承、转换器的角色。
分类:
1、容器适配器:改变容器接口。
STL提供两个容器迭代器:queue和stack。它们都是修饰deque后成为另一种风貌的容器。
2、迭代器适配器:改变迭代器接口。
- Insert Iterator:将容器绑定到back_insert_iterator、front_insert_iterator、insert_iterator。它们都是一个类,对它们的赋值操作将转换为对绑定容器的插入操作。为了操作方便,向用户提供的是一个函数,函数中才创建上述类。
以back_inserter为例:
~~~
template
inline back_insert_iterator back_inserter(Container& x) {
return back_insert_iterator(x); // 以容器为参数,创建迭代器适配器
}
~~~
注意,一般迭代器适配器不会以迭代器作为参数,这里通过传入一个容器创建一个迭代器适配器。
下面是back_insert_iterator类的定义:
~~~
template
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&
operator=(const typename Container::value_type& value) {
container->push_back(value);
return *this;
}
back_insert_iterator& operator*() { return *this; }
back_insert_iterator& operator++() { return *this; }
back_insert_iterator& operator++(int) { return *this; }
};
~~~
可以看到,迭代器适配器提供了自增和接引用的接口,但是实际的功能被关闭了。上述代码的关键在于,对迭代器适配器的赋值变为了对容器的插入操作。
下面是我自己写的一个类似于上面的迭代器适配器:
~~~
#include
#include
using namespace std;
template
class my_back_insert_iterator {
protected:
Container* container;
public:
explicit my_back_insert_iterator(Container& x) : container(&x) {}
my_back_insert_iterator&
operator=(const typename Container::value_type& value) {
container->push_back(value);
return *this;
}
};
int main()
{
vector vec;
my_back_insert_iterator< vector > back_insert(vec);
back_insert = 1;
back_insert = 2;
back_insert = 3;
back_insert = 4;
vector::iterator iter = vec.begin();
for ( ; iter != vec.end(); ++iter)
cout << *iter << endl;
return 0;
}
~~~
运行结果:
![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2016-08-11_57ac4c8b845d7.jpg)
对迭代器的赋值即是对容器的插入操作。
- 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 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 reverite(a+7);
cout << *reverite++ << " ";
cout << *reverite++ << " ";
cout << *reverite++ << " ";
~~~
运行结果:
![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2016-08-11_57ac4c8b999ef.jpg)
- IOStream Iterator:将迭代器(istream_iterator或ostream_iterator)绑定到某个iostream对象(cin/cout)上,从而操作这些IO对象。
以绑定标准输出为例,测试代码如下:
~~~
int a[] = {9,5,4,8,3,6,7};
ostream_iterator outite(cout, " "); // 输出数组元素时附带输出空格
copy(a, a+7, outite);
~~~
运行结果:
![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2016-08-11_57ac4c8bb57a9.jpg)
上述代码将迭代器适配器绑定到标准输出,并且每输出一个元素,附带输出一个空格符。对迭代器的赋值(operator=)就是对它的输出操作(operator<<)。源代码如下:
~~~
template
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& operator=(const T& value) {
*stream << value; // 关键点
if (string) *stream << string; // 输出间隔符
return *this;
}
// 以下三个操作都返回自己
ostream_iterator& operator*() { return *this; }
ostream_iterator& operator++() { return *this; }
ostream_iterator& 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(), 3));
~~~
则会调用如下函数:
~~~
template
void count_if(InputIterator first, InputIterator last, Predicate pred,
Size& n) {
for ( ; first != last; ++first)
if (pred(*first)) /* 对每个元素调用仿函数 */
++n; /* 满足条件则累加 */
}
~~~
下面看看pred,也就是bind2nd的源代码:
~~~
template
class binder2nd
: public unary_function {
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也需要提供这样的嵌套类型,使它变为可配接的。这在另一篇文章“仿函数”中也有所说明。
总结:
纵观整个适配器系统,基本上都是把某个对象或指向对象的指针封装在一个适配器类中,对适配器的操作最终都会传递到对所包含对象的操作上来。
参考:
《C++ primer》 P453.
《STL源码剖析》 第八章。
';