一、适配器
三种类型的适配器:
容器适配器:用来扩展7种基本容器,利用基本容器扩展形成了栈、队列和优先级队列
迭代器适配器:(反向迭代器、插入迭代器、IO流迭代器)
函数适配器:函数适配器能够将仿函数和另一个仿函数(或某个值、或某个一般函数)结合起来。
针对成员函数的函数适配器
针对一般函数的函数适配器
二、函数适配器示例
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
#include <iostream>
#include <algorithm> #include <functional> #include <vector> using namespace std; bool is_odd(int n) int main(void) cout << count_if(v.begin(), v.end(), is_odd) << endl; //计算奇数元素的个数 //bind1st(op, value)(param)相当于op(value, param); return 0; |
1
2 3 4 5 6 7 8 9 |
// TEMPLATE FUNCTION bind2nd
template < class _Fn2, class _Ty > inline binder2nd<_Fn2> bind2nd(const _Fn2 &_Func, const _Ty &_Right) { // return a binder2nd functor adapter typename _Fn2::second_argument_type _Val(_Right); return (std::binder2nd<_Fn2>(_Func, _Val)); } |
将匿名对象modulus<int>() 和 2 传递进去std::binder2nd<_Fn2>(_Func, _Val); 即是一个模板类对象,看binder2nd 模板类
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
// TEMPLATE CLASS binder2nd
template<class _Fn2> class binder2nd : public unary_function < typename _Fn2::first_argument_type, typename _Fn2::result_type > { // functor adapter _Func(left, stored) public: typedef unary_function < typename _Fn2::first_argument_type, typename _Fn2::result_type > _Base; typedef typename _Base::argument_type argument_type; typedef typename _Base::result_type result_type; binder2nd(const _Fn2 &_Func, result_type operator()(const argument_type &_Left) const result_type operator()(argument_type &_Left) const protected: |
即构造时,binder2nd 的2个成员op 和 value 分别用modulus<int>() 和 2 初始化。接着看count_if 中的主要代码:
for (; _First != _Last; ++_First)
++_Count;
*_First 就是遍历得到的容器元素了,当满足_Pred 条件时_Count++,此时可以看成是:
std::binder2nd< modulus<int> >(modulus<int>(), 2)(*_First) 也就是调用binder2nd 类的operator() 函数,返回 return (op(_Left, value));
也就是modulus<int>()(*_First, 2); 也就是调用modulus 类的operator() 函数,如下:
1
2 3 4 5 6 7 8 9 10 11 12 |
// TEMPLATE STRUCT modulus
template<class _Ty> struct modulus : public binary_function<_Ty, _Ty, _Ty> { // functor for operator% _Ty operator()(const _Ty &_Left, const _Ty &_Right) const { // apply operator% to operands return (_Left % _Right); } }; |
来说,可以理解成这样:bind2nd(op, value) (param)相当于op(param, value); 其中param 是元素值,value是需要绑定的参数,所谓
bind2nd 也即绑定第二个参数的意思,所以才说 bind2nd将二元函数对象modulus转换为一元函数对象,因为第二个参数就是2,当然
这里的第一个参数就是遍历得到的容器元素值了。
与bind2nd
类似的还有 bind1st,顾名思义是绑定第一个参数的意思,如下的表达式:
count_if(v.begin(), v.end(), bind1st(less<int>(), 4))
; 也就是说计算容器中大于4的元素个数。这里绑定的是左操作数。
三、函数适配器应用实例
(一)、针对成员函数的函数适配器
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
#include <iostream>
#include <algorithm> #include <functional> #include <vector> #include <string> using namespace std; class Person void foo(const vector<Person> &v) void foo2(const vector<Person *> &v) int main(void) vector<Person *> v2; |
在foo 函数中,第一行的mem_fun_ref 将空元函数转换为一元函数对象,具体流程大家可以自己跟踪代码,实际上跟上面bind2nd 是类似的,
需要稍微说一下的是传递函数指针的情况:
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
template < class _Result,
class _Ty > inline const_mem_fun_ref_t<_Result, _Ty> mem_fun_ref(_Result (_Ty::*_Pm)() const) { // return a const_mem_fun_ref_t functor adapter return (std::const_mem_fun_ref_t<_Result, _Ty>(_Pm)); } // TEMPLATE CLASS const_mem_fun_ref_t _Result operator()(const _Ty &_Left) const private: |
传入的参数是一个函数指针,也就是void (Person::*_Pm) () const , 传递后 _Pm = &Print,在operator() 函数中
return ((_Left.*_Pmemfun)()); _Left 也就是遍历到的Person 类对象,先找到类的函数,然后进行调用。
1
2 3 4 5 |
_Result operator()(_Ty &_Left, _Arg _Right) const
{ // call function with operand return ((_Left.*_Pmemfun)(_Right)); } |
也就是将第二个参数当作参数传递给PrintWithPrefix,所以打印出来的带有前缀person:
而mem_fun 就类似了,只不过此次for_each 遍历得到的是对象指针,所以进行函数调用时需要用-> 操作符,如下所示:
1
2 3 4 5 6 7 8 9 10 11 |
_Result operator()(const _Ty *_Pleft) const
{ // call function return ((_Pleft->*_Pmemfun)()); } _Result operator()(const _Ty *_Pleft, _Arg _Right) const |
(二)、针对一般函数的函数适配器
例程1:
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
#include <iostream>
#include <algorithm> #include <functional> #include <vector> #include <string> using namespace std; int main(void) return 0; |
ptr_fun 将strcmp 二元函数转换为二元函数对象,bind2nd 再将其转化为一元函数对象,即绑定了第二个参数,因为strcmp 是在比较
不相等的情况返回为真,故find_if 查找的是第一个不等于空串的串位置。
例程2:
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
#include <iostream>
#include <algorithm> #include <functional> #include <vector> #include <string> using namespace std; bool check(int elem) int main(void) vector<int>::iterator it; |
ptr_fun 做了一次转换,not1 再转换一次,故find_if 查找的是第一个大于等于3的元素位置。
这些代码的跟踪就留给大家自己完成了,篇幅所限,不能将所有调用过程都显现出来,学习STL还是得靠大家跟踪源码,才能有更深的体会。
参考:
C++ primer 第四版
Effective C++ 3rd
C++编程规范