泛型仿函数三

成员函数指针
有些C++编译器厂商定义出一种新型别，让你可以通过以下语法保存operator.*操作结果
void (__closure::* geronimosWork)()=
geronimo.*pActivity;
geronimosWork();
template<class ParaentFunctor,typename PointerToObj,typename PointerToMemFn>
class MemFunHandler:
public FunctorImpl<typename ParentFunctor::ResultType,typename ParentFunctor::ParmList>
{
public:
typedef typename ParentFunctor::ResultType ResultType;
MemFunHandler(const PointerToObj&pObj,PointerToMemFn pMemFn):
pObj_(pObj),pMemFn(pMemFn){}
MemFunHandler* Clone()const
{
return new MemFunHandler(*this);)
}
ResultType operator()
{
return ((*pObj_).*pMemFn_)();
}
ResultType operator(typename ParentFunctor::Parm1 p1)
{
return ((*pObj_).*pMemFn_)(p1);
}
ResultType operator(typename ParentFunctor::Parm1 p1,typename ParentFunctor::Parm1 p2)
{
return ((*pObj_).*pMemFn_)();
}
private:
PointerToObj pObj_;
PointerToMemFn pMenFn_;
}
#include "Functor.h"
#include <iostream>
class Parrot
{
public :
void Eat()
{
cout<<"Task,knick,tsk..\n";
}
void Speak()
{
count<<"Oh Captain,my Captain!\n";
}
};
int main()
{
Parrort geronimo;
Functor<>
cmd1(&geronmo,&Parrot::Eat),
cmd2(&geronimo,&Parrot::Speak);
cmd1();
cmd2();
}
绑定可以让Functor将部分环境联通计算一起保存下来，并逐步降低调用时刻所需环境需求
Incoming Functor和outgoing Functor,前者行别被当做参数ParentFunctor传递，后者型别则用于计算
template<class Incomming>
class BinderFirst:public FunctorImpl<typename Incoming::ResultType,typename Incoming::Arguments::Tail>
{
typedef Functor<typename Incoming::ResultType,Incoming::Arguments::Tail>Outgoing;
typedef typename Incoming::Parm1 Bound;
typedef typename Incoming::ResultType ResultType;
public:
BinderFirst(const Incoming& fun,Bound bound)
{


}
DEFINE_CLONE_FUNCTORIMPL(BinderFirst)
ResultType operator()()
{
return fun_(bound_);
}
ResultType operator()(typename Outgoing::Parm p1)
{
return fun_(bound_,p1);
}
ResultType operator()(typename Outgoing::Parm p1,typename Outgoing::Parm p2)
{
return fun_(bound_,p1,p2);
}
private:
Incoming fun_;
Bound bound_;
}


template<class Fctor>
typename Private::BinderFirstTraits<Fctor>::BoundFunctorType
BindFirst{
const Fctor&fun,typename Fctor::Param1 bound)
{
typedef typename
private::BinderFirstTraints<Fctor>::BoundFunctorType Outgoing;
return Outgoing(std::auto_ptr<typename Outgoing::Impl>){
new BinderFirst<Fctor>(fun,bound)));
}
}
}


const char * Fun(int i ,int j)
{
Functor<const char * ,TYPELIST_2(char ,int)f1(Fun);
Functor<std::string ,TYPELIST_1(double)>f2(BindFirst(f1,10));
f2(15);
}