泛型仿函数二

转发接口解决两个问题：参数类型与个数问题
泛型自动生成需要的那个
template <typename R ,class TList>
class Functor
{
typedef TList ParmList;
typedef typename TypeAtNonStrict<TList,0,EmptyType>::Result Parm1;
typedef typename TypeAtNonStrict<TList,1,EmptyType>::Result Parm2;
.....
public:
R operator()()
{
return (*spImpl_)();
}
R operator()(Parm1 p1)
{
return (*spImpl_)(p1);
}
R operator()(Parm1 p1,Parm2 p2)
{
return (*spImp1_)(p1,p2);
}
};
仿函数处理
Functor 被Fun参数化的templated构造函数
template <typename R ,class TList>
class Functor
{
...as above...
public:
templatte <class Fun>
Functor(const Fun&fun);
}


FunctorImpl<R,TList>派生class template FunctorHandler,保存一个型别为Fun的对象，并将operator()转发给该对象，
防止定义太多，Functor封装参数，并成为参数传递进去
template <class ParentFunctor,typename Fun>
class FunctorHandler:public FunctorImpl<typename ParentFunctor::ResultType,typename ParentFunctor::ParmList>
{
public :
typedef typename ParentFunctor::ResultType ResultType;
FunctorHandler(const Fun& fun):fun_(fun){}
FunctorHandler * Clone()const
{
return new FunctorHandler(*this);
}
ResultType operator()()
{
return fun_();
}
ResultType operator()(typename ParentFunctor::Parm1 p1)
{
return fun_(p1);
}
ResultType operator()(typename ParentFunctor::Parm1 p1,
typename ParentFunctor::Parm2 p2)
{
return fun_(p1,p2);
}
private:
Fun fun_;
};
如此，构造函数改写如下：
template <typename R,class TList>
template <typename Fun>
Functor <R,TList>::Functor(const Fun&fun)
:spIml_(new FunctorHandle<Functor,Fun>(fun));
{

}
实际为一个指向FunctorHandle 对象


泛函数=函数指针+型别推倒机制
当函数指针重载的时候，出现推导不明确，可采用赋值和转型
int main()
{
typedef void (*TpFun)(int ,double);
TpFun pF= TestFunction;
Functor<void,int,double>cmd1(pF);
cmd1(4,4.5);
Functor<void ,int ,double>cmd2(
static_cast<TpFun>(TestFunction));
cmd2(4,4.5)
}