代码改变世界

STL源码剖析之Adapter以及functor adapter初体验

2011-07-01 21:52  Aga.J  阅读(1037)  评论(0)  编辑  收藏  举报
1 adapter在设计模式上的定义如下：将一个class的接口转换为另一个class的接口，使得原本因为接口不兼容而不能合作的classes可以一起运作。
 
2 STL提供多种adapter，其中
改变functor（仿函数）的接口的叫做 function adapter。
改变 container（容器）接口的叫做container adapter
改变 iterator（迭代器）接口的叫做iterator adapter
 
3 container adapter
容器queue和stack就是一种container adapter，他们修饰deque的接口形成一种新的容器接口
 
4 iterator adapter
Insert iterator, reverse iterator, iostream iterator都属于 iterator adapter。
Insert iterator 将 一般的 iterator 的赋值操作（assign） 修饰为 插入（insert）操作，例如back_insert_iterator, front_insert_iterator, insert_iterator。
Reverse iterator 将 一般的iterator的前进方向逆转，使得原本应该前进的++操作变成了后退操作。
Iostream iterator 将 iterator 绑定到某个iostream上，使其拥有输入功能。
 
//use case
#include<iterator>
#include<deque>
#include<algorithm>
#include<iostream>
Int main()
{
Ostream_iterator<int> outite( cout, “ ” );
//将outite绑定到cout，每次对outite指派一个元素，然后就接一个” ”
Int ia[]={0,1,2,3,4,5};
Deque<int> id( ia, ia+6);
Copy ( id.begin(), id.end(0, outite); //相当于cout<<0 1 2….
Cout<<endl;
Copy( ia+1, ia+2, front_inserter( id) );
Copy( id.begin(), id.end(), outite); // 相当于cout<<1 0 1 2 3 4 5
Cout<<endl;
Copy( ia+3, ia+4, back_inserter(id));
Copy( id.begin(), id.end(), outite); // 10123453
Cout<<endl;
}
 
5 functor adapter
Functor adapter的价值在于，通过它们之间的绑定，组合，修饰，几乎可以无限制的创造出各种可能的表达式，搭配STL算法一起演出。例如，我们可能希望找出某个序列中所有不小于12的元素个数，虽然，“不小于“或者”大于或等于“，我们可以选择STL内建的仿函数greater_euqal，但是如果希望完全按照题目，可以这样做
Not1( bind2nd( less<int>(), 12 ))
这个式子将less的第二个参数绑定为12，再加上否定操作，就形成了不小于12的语义，凑成了一个表达式。 可以和任何”可接受表达式为参数”的算法匹配。
 
//use
#include< algorithm>
#include< functional>
#include< vector>
#include< iostream>
#include< iterator>
Using namespace std;
Int main()
{
Ostream_iterator<int> outite( cout,””);
Int ia[6]={2,21,12,7,19,23};
Vector<int> iv( ia, ia+6);
Foreach( iv.begin, iv.end, compose1( bind2nd( multiplies<int>(),3), bind2nd(plus<int>().2) ));
// 对每个元素v身上执行 (v+2)*3
Copy( iv.begin(), iv.end(), outite);
Cout<<endl;
Transform( iv.begin(), iv.end(), outite, compose1( bind2nd(multipies<int>(),3), bind2nd(plus<int> (),2 ) ));
Cout<<endl;
}
为什么会有functior adapter，因为仿函数就是将function call操作符重载的一种class，而任何算法接受一个仿函数时，在其演算过程中调用该仿函数的operator()， 这使得不具备仿函数之形，而又真函数之实的“一般函数“和”成员函数“感到为难，所以STL提供了众多的配接器，使得这些普通函数可以无缝的和其他配接器和算法结合起来。
//use case
#include< algorithm>
#include<functional>
#include<vector>
#include<iostream>
Using namespace std;
Void print(int i) //这里有个既存函数，希望可以在STL体系中复用
{ cout<<i<<’ ‘;}
Class Int
{
Public:
Explicit int(int i): m_i(i) {}
Void print1() const{cout<<’[’<<m_i<<’]’;} //这个函数也希望可以在STL体系中复用
Private:
Int m_i;
};
Int main()
{
Ostream_iterator< int> outite( cout, “ ” );
Int ia[6]={2,21,12,7,19,23};
Vector<int> iv( ia, ia+6);
Cout<<count_if ( iv,begin(), iv.end(), not1(bind2nd( less<int>(), 12));
Cout<<endl;
Transform( iv,begin() , iv,end(), outite, compose1( bind2nd( multiplies<int>(),3), bind2nd(plus<int>(),2) ));
Cout<<endl;
Copy( iv.begin(), iv.end(), outite);
Cout<<endl;
For_each( iv.begin(), iv.end(), print); //用函数指针搭配STL算法
For_each( iv.begin(), iv.end(), ptr_fun(print)); //用ptrfun修饰一般函数，并匹配STL算法
}
上述是各种function adapter和辅助函数，实际效果。
 
 
附网上的仿函数好文：
C++ STL 学习 ：for_each与仿函数(functor)（一）
 
 
C++ STL 学习 ：for_each与仿函数(functor)（一）
By zieckey( All right reserved!)
先看wikipedia定义：
A function object, also called a functor, functional, or functionoid,[1] is a computer programming construct allowing an object to be invoked or called like it was an ordinary function, usually with the same syntax.
简单来将，仿函数（functor）就是一个重载了"()"运算符的struct或class，利用对象支持operator()的特性，来达到模拟函数调用效果的技术。
我们平时对一个集合类遍历的时候，例如vector，是这样做的：
for(vector<int>::const_iterator iter = ivec.begin(); iter != ivec.end(); ++iter)
{
//do your whatever you want here
}
例如下面的代码：
#include <vector>
#include <iostream>
struct State
{
State( int state ) : m_state( state ){}
~State() { std::cout << "~State(), m_state=" << m_state << std::endl; }
void setState( int state ){ m_state = state; }
int getState() const{ return m_state; }
void print() const { std::cout << "State::print: " << m_state << std::endl; }
private:
int m_state;
};
int main()
{
std::vector<State*> vect;
vect.push_back( new State(0) );
vect.push_back( new State(1) );
vect.push_back( new State(2) );
vect.push_back( new State(3) );
std::vector<State*>::iterator it( vect.begin() );
std::vector<State*>::iterator ite( vect.end() );
for ( ; it != ite; ++it )
{
(*it)->print();
}
system( "pause" );
return 0;
}
这里的for循环语句有点冗余， ach ，为了使用for_each，我们需要定义一个函数，如下：
void print( State* pstate )
{
pstate->print();
}
于是就可以简化为下面代码：
std::for_each( vect.begin(), vect.end(), &print );
上面这段代码有点丑陋，看起来不太爽，主要是函数指针的原因。
在这种应用环境下，C++有仿函数来替代，我们定义一个仿函数，如下：
struct Printer
{
template<typename T> void operator()( T* t ) { t->print(); }
};
于是就可以简化为下面代码：
std::for_each( vect.begin(), vect.end(), Printer() );
下面，我们初步看下 for_each 的STL源码实现：
// TEMPLATE FUNCTION for_each
template<class _InIt,
class _Fn1> inline
_Fn1 for_each(_InIt _First, _InIt _Last, _Fn1 _Func)
{ // perform function for each element
_DEBUG_RANGE(_First, _Last);
_DEBUG_POINTER(_Func);
_CHECKED_BASE_TYPE(_InIt) _ChkFirst(_CHECKED_BASE(_First));
_CHECKED_BASE_TYPE(_InIt) _ChkLast(_CHECKED_BASE(_Last));
for (; _ChkFirst != _ChkLast; ++_ChkFirst)
_Func(*_ChkFirst);
return (_Func);
}
上面的代码看起来挺晕菜的，这里给出 effective STL 里面的一个实现，简单明了：
template< typename InputIterator, typename Function >
Function for_each( InputIterator beg, InputIterator end, Function f ) {
while ( beg != end )
f( *beg++ );
}
其实for_each就是一个模板函数，将for循环语句封装起来，前面两个参数都是迭代器，第三个参数是使用一个函数指针（或仿函数），
其功能是对每一个迭代器所指向的值调用仿函数。之前觉得for_each挺神秘的，其实看看源码也挺简单的。呵呵。
上面代码还是有点冗余，因为为了使用for_each还要单独定义一个函数（或仿函数），不太清爽，
呵呵，stl早为我们准备好了 mem_fun 模板函数来解决这个一个问题，于是代码再次简化为：
std::for_each( vect.begin(), vect.end(), std::mem_fun( &State::print ) ); //function adapter
我们一起看看 mem_fun 的STL源码实现：
// TEMPLATE FUNCTION mem_fun
template<class _Result,
class _Ty> inline
mem_fun_t<_Result, _Ty> mem_fun(_Result (_Ty::*_Pm)())
{ // return a mem_fun_t functor adapter
return (std::mem_fun_t<_Result, _Ty>(_Pm));
}
mem_fun 函数实际上是调用 mem_fun_t 函数，我们接着深入看看 mem_fun_t，
// TEMPLATE CLASS mem_fun_t
template<class _Result,
class _Ty>
class mem_fun_t
: public unary_function<_Ty *, _Result>
{ // functor adapter (*p->*pfunc)(), non-const *pfunc
public:
explicit mem_fun_t(_Result (_Ty::*_Pm)())
: _Pmemfun(_Pm)
{ // construct from pointer
}
_Result operator()(_Ty *_Pleft) const
{ // call function
return ((_Pleft->*_Pmemfun)());
}
private:
_Result (_Ty::*_Pmemfun)(); // the member function pointer
};
将上面这段代码定义的写的我们好看懂一点，如下：
// TEMPLATE CLASS mem_fun_t
template< typename _Result, typename _Ty >
class mem_fun_t : public unary_function<_Ty *, _Result>
{
typedef _Result (_Ty::*_Pmemfun)();
public:
explicit mem_fun_t( _Pmemfun& pfunc )
: m_pfun( pfunc )
{ // construct from pointer
}
_Result operator()(_Ty *_Pleft) const
{ // call function
return ( (_Pleft->*m_pfun)() );
}
private:
_Pmemfun m_pfun; // the member function pointer
};
这样就比较清晰了，定义了仿函数mem_fun_t内部定义了一个类成员函数指针，
仿函数构造的时候将函数指针保存起来，当仿函数operator()被调用的时候，
就通过与一个类的实例关联起来从而实现了类成员函数的调用。
其调用流程是这样的，for_each把vector中的元素传送给mem_fun，
mem_fun自己产生一个仿函数mem_fun_t，然后仿函数调用其重载的()。
上述源码还有最后一个没有说明，就是unary_function，直接上源码：
// TEMPLATE STRUCT unary_function
template<class _Arg,
class _Result>
struct unary_function
{ // base class for unary functions
typedef _Arg argument_type;
typedef _Result result_type;
};
就一个模板结构体。没有数据成员，非常简单。
最后，定义一个删除指针的仿函数：
struct DeletePointer
{
template<typename T> void operator()( T* ptr ) const { delete ptr; }
};
然后调用，就一个逐一删除vector里面的所有元素了。
std::for_each( vect.begin(), vect.end(), DeletePointer() );
源码：
#include <vector>
#include <iostream>
#include <algorithm>
#include <functional>
struct State
{
State( int state ) : m_state( state ){}
~State() { std::cout << "~State(), m_state=" << m_state << std::endl; }
void setState( int state ){ m_state = state; }
int getState() const{ return m_state; }
void print() const { std::cout << "State::print: " << m_state << std::endl; }
private:
int m_state;
};
void print( State* pstate )
{
pstate->print();
}
struct Printer
{
template<typename T> void operator()( T* t ) { t->print(); }
};
struct DeletePointer
{
template<typename T> void operator()( T* ptr ) const { delete ptr; }
};
int main()
{
std::vector<State*> vect;
vect.push_back( new State(0) );
vect.push_back( new State(1) );
vect.push_back( new State(2) );
vect.push_back( new State(3) );
std::vector<State*>::iterator it( vect.begin() );
std::vector<State*>::iterator ite( vect.end() );
for ( ; it != ite; ++it )
{
(*it)->print();
}
std::for_each( vect.begin(), vect.end(), &print );
std::for_each( vect.begin(), vect.end(), Printer() );
std::for_each( vect.begin(), vect.end(), std::mem_fun( &State::print ) );
std::for_each( vect.begin(), vect.end(), DeletePointer() );
vect.clear();
system( "pause" );
return 0;
}
 
//源码实现与分析
#include<vector>
#include<iostream>
#include <algorithm>
#include <functional>
using namespace std;
struct State
{
public:
State(int state):m_state(state){}
~State(){std::cout<<"~state(),m_state="<<m_state;}
void setState(int state){m_state=state;}
int getState(){return m_state;}
void print() const {std::cout<<"State:print:"<<m_state<<std::endl;}
private:
int m_state;
};
void print(State* pstate)
{
(pstate)->print();
}
struct Printer
{
template<typename T> void operator()(T* t){t->print();}
};
int main()
{
std::vector<State*> vect;
vect.push_back(new State(0));
vect.push_back( new State(1) );
vect.push_back( new State(2) );
vect.push_back( new State(3) );
std::vector<State*>::iterator it(vect.begin());
std::vector<State*>::iterator ite(vect.end());
 
//传统的遍历需要我们取得迭代子进行对象的访问
for(;it!=ite;++it)
{
(*it)->print();
}
 
 
//可以尝试使用std自带的for_each,但是需要使用一个函数指针来实现。
std::for_each(vect.begin(),vect.end(),&print);
//其实for_each还是使用了for和迭代器，并把迭代器作为指针函数的参数传入来调用。
/*
template<class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last, Function f)
{
for ( ; first!=last; ++first ) f(*first);
return f;
}
http://www.cplusplus.com/reference/algorithm/for_each/
*/
 
//下面试一试使用仿函数，需要先定义一个functor
Printer p;
std::for_each(vect.begin(),vect.end(),p);
//同样利用for_each函数，但是这次我们在模板参数中传入一个类对象，在foreach中使用对象的()操作符时调用所重载的函数，实现我们的目的
// 还是需要自己定义一个仿函数，这次试试function adapter
std::for_each(vect.begin(),vect.end(), std::mem_fun(&State::print));
/*
mem_fun的实现是怎样？
// TEMPLATE FUNCTION mem_fun
template<class _Result,class _Ty> inline
mem_fun_t<_Result, _Ty> mem_fun(_Result (_Ty::*_Pm)())
{ // return a mem_fun_t functor adapter
return (std::mem_fun_t<_Result, _Ty>(_Pm));
}
注意mem_fun的参数_Result(_Ty::*_Pm)()
注意函数实现中调用了mem_fun_t这个functor adapter
// TEMPLATE CLASS mem_fun_t
template< typename _Result, typename _Ty >
class mem_fun_t : public unary_function<_Ty *, _Result> //继承已有的unary_funcion
{
typedef _Result (_Ty::*_Pmemfun)();
public:
explicit mem_fun_t( _Pmemfun& pfunc )
: m_pfun( pfunc )
{ // construct from pointer
}
_Result operator()(_Ty *_Pleft) const
{ // call function
return ( (_Pleft->*m_pfun)() );
}
private:
_Pmemfun m_pfun; // the member function pointer
};
这样就比较清晰了，定义了仿函数mem_fun_t内部定义了一个【类成员函数指针】，
仿函数构造的时候将函数指针保存起来，当仿函数operator()被调用的时候，
就通过与一个类的实例关联起来从而实现了类成员函数的调用。
其调用流程是这样的，for_each把vector中的元素传送给mem_fun，
mem_fun【自己产生一个仿函数mem_fun_t】，然后仿函数调用其重载的()。
所以这里的functor adapter其实就是帮助我们实现一个仿函数来实现和算法的组合等便捷功能。
而且注意到mem_fun_t是如何帮助我们自动实现一个仿函数的
他需要我们传入&State:print，这时候其实也就记录了State类和print函数指针，还有print函数返回值【分别对应Ty Pm Result】然后再根据这些信息来实现一个仿函数，
*/
int i;
std::cin>>i;
}
//见C++ Reference解释：

ptr_fun

Convert function pointer to function object
Returns a function object that encapsulates function f.
也就是书里面介绍的方法（将一个普通函数转化为仿函数）
mem_fun
Convert member function to function object (pointer version)
Returns a function object that encapsulates member function f of type T. The member function returns a value of type S and, optionally, can take one parameter of type A.
也就是网上文章中介绍的方法（将一个类成员函数转化为仿函数）