在既有代码中编程时，如果想对一个数据集(容器/数组)中的所有元素进行处理时，其处理函数一般只能接受一个参数－－数据集的数据类型，而既有的接口可能需要多个参数－－数据集的数据类型只是这多个需求参数中的一个参数。在通常情况下，如果想使用标准算法中的forEach算法，则需要就此功能另外再写一个函数/函数对象以把额外的参数封装在函数内部，或者直接自己遍历这个数据集，把既有函数中的代码Ctrl+C/Ctrl+V到遍历处，无论怎样，这都额外增加了工作量，而且有可能因为疏忽而出错。
下面的代码就是为了解决这一问题而实现的：把一个多元函数(最少一元，最多五元)转换为一元函数，以供遍历算法forEach使用。
R (*)(P1); ==> R (*)(P1)
R (*)(P1,P2); ==> R (*)(P1) / R (*)(P2)
R (*)(P1,P2,P3); ==> R (*)(P1) / R (*)(P2)/ R (*)(P3)
R (*)(P1,P2,P3,P4);
==> R (*)(P1) / R (*)(P2)/ R (*)(P3)/R (*)(P4)
R (*)(P1,P2,P3,P4,P5);
==> R (*)(P1) / R (*)(P2)/ R (*)(P3)/R (*)(P4)/R(*)(P5)
R (O::*)(); ==> R (*)(O&)
R (O::*)(P1);
==> R (*)(O&) / R (*)(P1)
R (O::*)(P1,P2);
==> R (*)(O&)
/ R (*)(P1) /
R (*)(P2)
R (O::*)(P1,P2,P3); ...
R (O::*)(P1,P2,P3,P4); ...
R (O::*)(P1,P2,P3,P4,P5); ...
上面的列表提供了转换支持功能集：可以把既有函数列表中的任何一个参数作为新的函数接口的传入参数，这样就极大地增强了使用灵活性：所需要的新函数的参数，可能是旧函数的第0，1，2，3，4，5个参数中的任意一个。其中0表示是成员函数的对象类型。
如果执行了错误的转换，则编译时会失败，从而保证了能够通过的转换都是正确的，将代码的逻辑功能正确性交付给了编译器来验错－－这正是元代码的最让人兴奋的威力，我相信编译器出错的概率相对于编程者来说是可以忽略不计的。
#ifndef unaryFunctor_h__
#define unaryFunctor_h__
/********************************************************************
created:
2014-1-9 15:35
author:
Shen Tony
purpose:
create interface to convert (global /member) function into unary function ,this function supports 5 parameters dynamical at most. e.g.
R (*)(P1);
R (*)(P1,P2);
R (*)(P1,P2,P3);
R (*)(P1,P2,P3,P4);
R (*)(P1,P2,P3,P4,P5);
R (O::*)();
R (O::*)(P1);
R (O::*)(P1,P2);
R (O::*)(P1,P2,P3);
R (O::*)(P1,P2,P3,P4);
R (O::*)(P1,P2,P3,P4,P5);
UnaryFunction<F,x> : No.x parameter of functor F is input parameter in every call.
FunctionParams<F>::Return_T is the return type of every calling
*********************************************************************/
#include "typeTraits.h"
#include "functionTraits.h"
namespace MiniMPL
{
///////////////////////////////////////////UnaryFunction compile period compenment//////////////////////////////////////////////
template<typename F,bool bMemberFunctionPointer=IsMemberFunctionPointer<F>::value,unsigned int N=FunctionParams<F>::ParamNum> struct InitParamsImpl;
//member function
template<typename F> struct InitParamsImpl<F,true,0>
{
template<int Idx> struct apply;
template<> struct apply<0> : public Type2Type<ParmHolder<> > { } ;
};
template<typename F> struct InitParamsImpl<F,true,1>
{
template<int Idx> struct apply;
template<> struct apply<0> : public Type2Type<ParmHolder<FP(F,1)> > { } ;
template<> struct apply<1> : public Type2Type<ParmHolder<FP(F,0)> > { } ;
};
template<typename F> struct InitParamsImpl<F,true,2>
{
template<int Idx> struct apply;
template<> struct apply<0> : public Type2Type<ParmHolder<FP(F,1),FP(F,2)> > { } ;
template<> struct apply<1> : public Type2Type<ParmHolder<FP(F,0),FP(F,2)> > { } ;
template<> struct apply<2> : public Type2Type<ParmHolder<FP(F,0),FP(F,1)> > { } ;
};
template<typename F> struct InitParamsImpl<F,true,3>
{
template<int Idx> struct apply;
template<> struct apply<0> : public Type2Type<ParmHolder<FP(F,1),FP(F,2),FP(F,3)> > { } ;
template<> struct apply<1> : public Type2Type<ParmHolder<FP(F,0),FP(F,2),FP(F,3)> > { } ;
template<> struct apply<2> : public Type2Type<ParmHolder<FP(F,0),FP(F,1),FP(F,3)> > { } ;
template<> struct apply<3> : public Type2Type<ParmHolder<FP(F,0),FP(F,1),FP(F,2)> > { } ;
};
template<typename F> struct InitParamsImpl<F,true,4>
{
template<int Idx> struct apply;
template<> struct apply<0> : public Type2Type<ParmHolder<FP(F,1),FP(F,2),FP(F,3),FP(F,4)> > { } ;
template<> struct apply<1> : public Type2Type<ParmHolder<FP(F,0),FP(F,2),FP(F,3),FP(F,4)> > { } ;
template<> struct apply<2> : public Type2Type<ParmHolder<FP(F,0),FP(F,1),FP(F,3),FP(F,4)> > { } ;
template<> struct apply<3> : public Type2Type<ParmHolder<FP(F,0),FP(F,1),FP(F,2),FP(F,4)> > { } ;
template<> struct apply<4> : public Type2Type<ParmHolder<FP(F,0),FP(F,1),FP(F,2),FP(F,3)> > { } ;
};
template<typename F> struct InitParamsImpl<F,true,5>
{
template<int Idx> struct apply;
template<> struct apply<0> : public Type2Type<ParmHolder<FP(F,1),FP(F,2),FP(F,3),FP(F,4),FP(F,5)> > { } ;
template<> struct apply<1> : public Type2Type<ParmHolder<FP(F,0),FP(F,2),FP(F,3),FP(F,4),FP(F,5)> > { } ;
template<> struct apply<2> : public Type2Type<ParmHolder<FP(F,0),FP(F,1),FP(F,3),FP(F,4),FP(F,5)> > { } ;
template<> struct apply<3> : public Type2Type<ParmHolder<FP(F,0),FP(F,1),FP(F,2),FP(F,4),FP(F,5)> > { } ;
template<> struct apply<4> : public Type2Type<ParmHolder<FP(F,0),FP(F,1),FP(F,2),FP(F,3),FP(F,5)> > { } ;
template<> struct apply<5> : public Type2Type<ParmHolder<FP(F,0),FP(F,1),FP(F,2),FP(F,3),FP(F,4)> > { } ;
};
//non-member function
template<typename F> struct InitParamsImpl<F,false,0>
{
template<int Idx> struct apply : public Type2Type<ParmHolder<> > { };
};
template<typename F> struct InitParamsImpl<F,false,1>
{
template<int Idx> struct apply;
template<> struct apply<1> : public Type2Type<ParmHolder<> > { };
};
template<typename F> struct InitParamsImpl<F,false,2>
{
template<int Idx> struct apply;
template<> struct apply<1> : public Type2Type<ParmHolder<FP(F,2)> > { };
template<> struct apply<2> : public Type2Type<ParmHolder<FP(F,1)> > { };
};
template<typename F> struct InitParamsImpl<F,false,3>
{
template<int Idx> struct apply;
template<> struct apply<1> : public Type2Type<ParmHolder<FP(F,2),FP(F,3)> > { };
template<> struct apply<2> : public Type2Type<ParmHolder<FP(F,1),FP(F,3)> > { };
template<> struct apply<3> : public Type2Type<ParmHolder<FP(F,1),FP(F,2)> > { };
};
template<typename F> struct InitParamsImpl<F,false,4>
{
template<int Idx> struct apply;
template<> struct apply<1> : public Type2Type<ParmHolder<FP(F,2),FP(F,3),FP(F,4)> > { };
template<> struct apply<2> : public Type2Type<ParmHolder<FP(F,1),FP(F,3),FP(F,4)> > { };
template<> struct apply<3> : public Type2Type<ParmHolder<FP(F,1),FP(F,2),FP(F,4)> > { };
template<> struct apply<4> : public Type2Type<ParmHolder<FP(F,1),FP(F,2),FP(F,3)> > { };
};
template<typename F> struct InitParamsImpl<F,false,5>
{
template<int Idx> struct apply;
template<> struct apply<1> : public Type2Type<ParmHolder<FP(F,2),FP(F,3),FP(F,4),FP(F,5)> > { };
template<> struct apply<2> : public Type2Type<ParmHolder<FP(F,1),FP(F,3),FP(F,4),FP(F,5)> > { };
template<> struct apply<3> : public Type2Type<ParmHolder<FP(F,1),FP(F,2),FP(F,4),FP(F,5)> > { };
template<> struct apply<4> : public Type2Type<ParmHolder<FP(F,1),FP(F,2),FP(F,3),FP(F,5)> > { };
template<> struct apply<5> : public Type2Type<ParmHolder<FP(F,1),FP(F,2),FP(F,3),FP(F,4)> > { };
};
template<typename F,int Idx> struct InitParams : public InitParamsImpl<F>::template apply<Idx> {};
///////////////////////////////////////////UnaryFunction Runtime period compenment///////////////////////////////////////
template<typename F,int Idx> struct UnaryFunction; //forward declaration
#define InitParms_T(F,idx) typename InitParams<F,idx>::type
//member function
template<typename F,bool bMemberFunctionPointer=IsMemberFunctionPointer<F>::value,unsigned int N=FunctionParams<F>::ParamNum> struct CreateUnaryFunctionImpl;
template<typename F> struct CreateUnaryFunctionImpl<F,true,0> //prototype : R (O::*)()
{
typedef FPP(F,0) TP0;
static UnaryFunction<F,0> create(F f,_) { return UnaryFunction<F,0>(f,InitParms_T(F,0)()); };
static FR(F) call(UnaryFunction<F,0>& functorWrp,TP0 p0) { return (p0.*(functorWrp.m_f))(); }
};
template<typename F> struct CreateUnaryFunctionImpl<F,true,1> //prototype : R (O::*)(P1)
{
typedef FPP(F,0) TP0;
typedef FPP(F,1) TP1;
static UnaryFunction<F,0> create(F f, _, TP1 p1 ) { return UnaryFunction<F,0>(f,InitParms_T(F,0)(p1)); };
static UnaryFunction<F,1> create(F f, TP0 p0, _ ) { return UnaryFunction<F,1>(f,InitParms_T(F,1)(p0)); };
static FR(F) call(UnaryFunction<F,0>& functorWrp,TP0 p0) { return (p0.*(functorWrp.m_f))(functorWrp.m_Ps.m_p1); }
static FR(F) call(UnaryFunction<F,1>& functorWrp,TP1 p1) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(p1); }
};
template<typename F> struct CreateUnaryFunctionImpl<F,true,2> //prototype : R (O::*)(P1,P2)
{
typedef FPP(F,0) TP0;
typedef FPP(F,1) TP1;
typedef FPP(F,2) TP2;
static UnaryFunction<F,0> create(F f, _, TP1 p1, TP2 p2) { return UnaryFunction<F,0>(f,InitParms_T(F,0)(p1,p2)); };
static UnaryFunction<F,1> create(F f, TP0 p0, _, TP2 p2) { return UnaryFunction<F,1>(f,InitParms_T(F,1)(p0,p2)); };
static UnaryFunction<F,2> create(F f, TP0 p0, TP1 p1, _) { return UnaryFunction<F,2>(f,InitParms_T(F,2)(p0,p1)); };
static FR(F) call(UnaryFunction<F,0>& functorWrp,TP0 p0) { return (p0.*(functorWrp.m_f))(functorWrp.m_Ps.m_p1,functorWrp.m_Ps.m_p2); }
static FR(F) call(UnaryFunction<F,1>& functorWrp,TP1 p1) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(p1,functorWrp.m_Ps.m_p2); }
static FR(F) call(UnaryFunction<F,2>& functorWrp,TP2 p2) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(functorWrp.m_Ps.m_p2,p2); }
};
template<typename F> struct CreateUnaryFunctionImpl<F,true,3> //prototype : R (O::*)(P1,P2,P3)
{
typedef FPP(F,0) TP0;
typedef FPP(F,1) TP1;
typedef FPP(F,2) TP2;
typedef FPP(F,3) TP3;
static UnaryFunction<F,0> create(F f, _, TP1 p1, TP2 p2, TP3 p3) { return UnaryFunction<F,0>(f,InitParms_T(F,0)(p1,p2,p3)); };
static UnaryFunction<F,1> create(F f, TP0 p0, _, TP2 p2, TP3 p3) { return UnaryFunction<F,1>(f,InitParms_T(F,1)(p0,p2,p3)); };
static UnaryFunction<F,2> create(F f, TP0 p0, TP1 p1, _, TP3 p3) { return UnaryFunction<F,2>(f,InitParms_T(F,2)(p0,p1,p3)); };
static UnaryFunction<F,3> create(F f, TP0 p0, TP1 p1, TP2 p2, _) { return UnaryFunction<F,3>(f,InitParms_T(F,3)(p0,p1,p2)); };
static FR(F) call(UnaryFunction<F,0>& functorWrp,TP0 p0) { return (p0.*(functorWrp.m_f))(functorWrp.m_Ps.m_p1,functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3); }
static FR(F) call(UnaryFunction<F,1>& functorWrp,TP1 p1) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(p1,functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3); }
static FR(F) call(UnaryFunction<F,2>& functorWrp,TP2 p2) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(functorWrp.m_Ps.m_p2,p2,functorWrp.m_Ps.m_p3); }
static FR(F) call(UnaryFunction<F,3>& functorWrp,TP3 p3) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,p3); }
};
template<typename F> struct CreateUnaryFunctionImpl<F,true,4> //prototype : R (O::*)(P1,P2,P3,P4)
{
typedef FPP(F,0) TP0;
typedef FPP(F,1) TP1;
typedef FPP(F,2) TP2;
typedef FPP(F,3) TP3;
typedef FPP(F,4) TP4;
static UnaryFunction<F,0> create(F f, _, TP1 p1, TP2 p2, TP3 p3, TP4 p4) { return UnaryFunction<F,0>(f,InitParms_T(F,0)(p1,p2,p3,p4)); };
static UnaryFunction<F,1> create(F f, TP0 p0, _, TP2 p2, TP3 p3, TP4 p4) { return UnaryFunction<F,1>(f,InitParms_T(F,1)(p0,p2,p3,p4)); };
static UnaryFunction<F,2> create(F f, TP0 p0, TP1 p1, _, TP3 p3, TP4 p4) { return UnaryFunction<F,2>(f,InitParms_T(F,2)(p0,p1,p3,p4)); };
static UnaryFunction<F,3> create(F f, TP0 p0, TP1 p1, TP2 p2, _, TP4 p4) { return UnaryFunction<F,3>(f,InitParms_T(F,3)(p0,p1,p2,p4)); };
static UnaryFunction<F,4> create(F f, TP0 p0, TP1 p1, TP2 p2, TP3 p3, _) { return UnaryFunction<F,4>(f,InitParms_T(F,4)(p0,p1,p2,p3)); };
static FR(F) call(UnaryFunction<F,0>& functorWrp,TP0 p0) { return (p0.*(functorWrp.m_f))(functorWrp.m_Ps.m_p1,functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,functorWrp.m_Ps.m_p4); }
static FR(F) call(UnaryFunction<F,1>& functorWrp,TP1 p1) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(p1,functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,functorWrp.m_Ps.m_p4); }
static FR(F) call(UnaryFunction<F,2>& functorWrp,TP2 p2) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(functorWrp.m_Ps.m_p2,p2,functorWrp.m_Ps.m_p3,functorWrp.m_Ps.m_p4); }
static FR(F) call(UnaryFunction<F,3>& functorWrp,TP3 p3) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,p3,functorWrp.m_Ps.m_p4); }
static FR(F) call(UnaryFunction<F,4>& functorWrp,TP4 p4) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,functorWrp.m_Ps.m_p4,p4); }
};
template<typename F> struct CreateUnaryFunctionImpl<F,true,5> //prototype : R (O::*)(P1,P2,P3,P4,P5)
{
typedef FPP(F,0) TP0;
typedef FPP(F,1) TP1;
typedef FPP(F,2) TP2;
typedef FPP(F,3) TP3;
typedef FPP(F,4) TP4;
typedef FPP(F,5) TP5;
static UnaryFunction<F,0> create(F f, _, TP1 p1, TP2 p2, TP3 p3, TP4 p4, TP5 p5) { return UnaryFunction<F,0>(f,InitParms_T(F,0)(p1,p2,p3,p4,p5)); };
static UnaryFunction<F,1> create(F f, TP0 p0, _, TP2 p2, TP3 p3, TP4 p4, TP5 p5) { return UnaryFunction<F,1>(f,InitParms_T(F,1)(p0,p2,p3,p4,p5)); };
static UnaryFunction<F,2> create(F f, TP0 p0, TP1 p1, _, TP3 p3, TP4 p4, TP5 p5) { return UnaryFunction<F,2>(f,InitParms_T(F,2)(p0,p1,p3,p4,p5)); };
static UnaryFunction<F,3> create(F f, TP0 p0, TP1 p1, TP2 p2, _, TP4 p4, TP5 p5) { return UnaryFunction<F,3>(f,InitParms_T(F,3)(p0,p1,p2,p4,p5)); };
static UnaryFunction<F,4> create(F f, TP0 p0, TP1 p1, TP2 p2, TP3 p3, _, TP5 p5) { return UnaryFunction<F,4>(f,InitParms_T(F,4)(p0,p1,p2,p3,p5)); };
static UnaryFunction<F,5> create(F f, TP0 p0, TP1 p1, TP2 p2, TP3 p3, TP4 p4, _) { return UnaryFunction<F,5>(f,InitParms_T(F,5)(p0,p1,p2,p3,p4)); };
static FR(F) call(UnaryFunction<F,0>& functorWrp,TP0 p0) { return (p0.*(functorWrp.m_f))(functorWrp.m_Ps.m_p1,functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,functorWrp.m_Ps.m_p4,functorWrp.m_Ps.m_p5); }
static FR(F) call(UnaryFunction<F,1>& functorWrp,TP1 p1) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(p1,functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,functorWrp.m_Ps.m_p4,functorWrp.m_Ps.m_p5); }
static FR(F) call(UnaryFunction<F,2>& functorWrp,TP2 p2) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(functorWrp.m_Ps.m_p2,p2,functorWrp.m_Ps.m_p3,functorWrp.m_Ps.m_p4,functorWrp.m_Ps.m_p5); }
static FR(F) call(UnaryFunction<F,3>& functorWrp,TP3 p3) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,p3,functorWrp.m_Ps.m_p4,functorWrp.m_Ps.m_p5); }
static FR(F) call(UnaryFunction<F,4>& functorWrp,TP4 p4) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,functorWrp.m_Ps.m_p4,p4,functorWrp.m_Ps.m_p5); }
static FR(F) call(UnaryFunction<F,5>& functorWrp,TP5 p5) { return ((functorWrp.m_Ps.m_p1).*(functorWrp.m_f))(functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,functorWrp.m_Ps.m_p4,functorWrp.m_Ps.m_p5,p5); }
};
//non-member function
template<typename F> struct CreateUnaryFunctionImpl<F,false,1> //prototype : R (*)(P1)
{
typedef FPP(F,1) TP1;
static UnaryFunction<F,1> create(F f, _) { return UnaryFunction<F,1>(f,InitParms_T(F,1)()); };
static FR(F) call(UnaryFunction<F,1>& functorWrp,TP1 p1) { return (functorWrp.m_f)(p1); }
};
template<typename F> struct CreateUnaryFunctionImpl<F,false,2> //prototype : R (*)(P1,P2)
{
typedef FPP(F,1) TP1;
typedef FPP(F,2) TP2;
static UnaryFunction<F,1> create(F f, _, TP2 p2) { return UnaryFunction<F,1>(f,InitParms_T(F,1)(p2)); };
static UnaryFunction<F,2> create(F f, TP1 p1, _) { return UnaryFunction<F,2>(f,InitParms_T(F,2)(p1)); };
static FR(F) call(UnaryFunction<F,1>& functorWrp,TP1 p1) { return (functorWrp.m_f)(p1,functorWrp.m_Ps.m_p1); }
static FR(F) call(UnaryFunction<F,2>& functorWrp,TP2 p2) { return (functorWrp.m_f)(functorWrp.m_Ps.m_p1,p2); }
};
template<typename F> struct CreateUnaryFunctionImpl<F,false,3> //prototype : R (*)(P1,P2,P3)
{
typedef FPP(F,1) TP1;
typedef FPP(F,2) TP2;
typedef FPP(F,3) TP3;
static UnaryFunction<F,1> create(F f, _, TP2 p2, TP3 p3) { return UnaryFunction<F,1>(f,InitParms_T(F,1)(p2,p3)); };
static UnaryFunction<F,2> create(F f, TP1 p1, _, TP3 p3) { return UnaryFunction<F,2>(f,InitParms_T(F,2)(p1,p3)); };
static UnaryFunction<F,3> create(F f, TP1 p1, TP2 p2, _) { return UnaryFunction<F,3>(f,InitParms_T(F,3)(p1,p2)); };
static FR(F) call(UnaryFunction<F,1>& functorWrp,TP1 p1) { return (functorWrp.m_f)(p1,functorWrp.m_Ps.m_p1,functorWrp.m_Ps.m_p2); }
static FR(F) call(UnaryFunction<F,2>& functorWrp,TP2 p2) { return (functorWrp.m_f)(functorWrp.m_Ps.m_p1,p2,functorWrp.m_Ps.m_p2); }
static FR(F) call(UnaryFunction<F,3>& functorWrp,TP3 p3) { return (functorWrp.m_f)(functorWrp.m_Ps.m_p1,functorWrp.m_Ps.m_p2,p3); }
};
template<typename F> struct CreateUnaryFunctionImpl<F,false,4> //prototype : R (*)(P1,P2,P3,P4)
{
typedef FPP(F,1) TP1;
typedef FPP(F,2) TP2;
typedef FPP(F,3) TP3;
typedef FPP(F,4) TP4;
static UnaryFunction<F,1> create(F f, _, TP2 p2, TP3 p3, TP4 p4) { return UnaryFunction<F,1>(f,InitParms_T(F,1)(p2,p3,p4)); };
static UnaryFunction<F,2> create(F f, TP1 p1, _, TP3 p3, TP4 p4) { return UnaryFunction<F,2>(f,InitParms_T(F,2)(p1,p3,p4)); };
static UnaryFunction<F,3> create(F f, TP1 p1, TP2 p2, _, TP4 p4) { return UnaryFunction<F,3>(f,InitParms_T(F,3)(p1,p2,p4)); };
static UnaryFunction<F,4> create(F f, TP1 p1, TP2 p2, TP3 p3, _) { return UnaryFunction<F,4>(f,InitParms_T(F,4)(p1,p2,p3)); };
static FR(F) call(UnaryFunction<F,1>& functorWrp,TP1 p1) { return (functorWrp.m_f)(p1,functorWrp.m_Ps.m_p1,functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3); }
static FR(F) call(UnaryFunction<F,2>& functorWrp,TP2 p2) { return (functorWrp.m_f)(functorWrp.m_Ps.m_p1,p2,functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3); }
static FR(F) call(UnaryFunction<F,3>& functorWrp,TP3 p3) { return (functorWrp.m_f)(functorWrp.m_Ps.m_p1,functorWrp.m_Ps.m_p2,p3,functorWrp.m_Ps.m_p3); }
static FR(F) call(UnaryFunction<F,4>& functorWrp,TP4 p4) { return (functorWrp.m_f)(functorWrp.m_Ps.m_p1,functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,p4); }
};
template<typename F> struct CreateUnaryFunctionImpl<F,false,5> //prototype : R (*)(P1,P2,P3,P4,P5)
{
typedef FPP(F,1) TP1;
typedef FPP(F,2) TP2;
typedef FPP(F,3) TP3;
typedef FPP(F,4) TP4;
typedef FPP(F,5) TP5;
static UnaryFunction<F,1> create(F f, _, TP2 p2, TP3 p3, TP4 p4, TP5 p5) { return UnaryFunction<F,1>(f,InitParms_T(F,1)(p2,p3,p4,p5)); };
static UnaryFunction<F,2> create(F f, TP1 p1, _, TP3 p3, TP4 p4, TP5 p5) { return UnaryFunction<F,2>(f,InitParms_T(F,2)(p1,p3,p4,p5)); };
static UnaryFunction<F,3> create(F f, TP1 p1, TP2 p2, _, TP4 p4, TP5 p5) { return UnaryFunction<F,3>(f,InitParms_T(F,3)(p1,p2,p4,p5)); };
static UnaryFunction<F,4> create(F f, TP1 p1, TP2 p2, TP3 p3, _, TP5 p5) { return UnaryFunction<F,4>(f,InitParms_T(F,4)(p1,p2,p3,p5)); };
static UnaryFunction<F,5> create(F f, TP1 p1, TP2 p2, TP3 p3, TP4 p4, _) { return UnaryFunction<F,5>(f,InitParms_T(F,5)(p1,p2,p3,p4)); };
static FR(F) call(UnaryFunction<F,1>& functorWrp,TP1 p1) { return (functorWrp.m_f)(p1,functorWrp.m_Ps.m_p1,functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,functorWrp.m_Ps.m_p4); }
static FR(F) call(UnaryFunction<F,2>& functorWrp,TP2 p2) { return (functorWrp.m_f)(functorWrp.m_Ps.m_p1,p2,functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,functorWrp.m_Ps.m_p4); }
static FR(F) call(UnaryFunction<F,3>& functorWrp,TP3 p3) { return (functorWrp.m_f)(functorWrp.m_Ps.m_p1,functorWrp.m_Ps.m_p2,p3,functorWrp.m_Ps.m_p3,functorWrp.m_Ps.m_p4); }
static FR(F) call(UnaryFunction<F,4>& functorWrp,TP4 p4) { return (functorWrp.m_f)(functorWrp.m_Ps.m_p1,functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,p4,functorWrp.m_Ps.m_p4); }
static FR(F) call(UnaryFunction<F,5>& functorWrp,TP5 p5) { return (functorWrp.m_f)(functorWrp.m_Ps.m_p1,functorWrp.m_Ps.m_p2,functorWrp.m_Ps.m_p3,functorWrp.m_Ps.m_p4,p5); }
};
}
#endif // unaryFunctor_h__
4) 将多元函数转换为一元函数unaryFunctionConverter [原创,泛型编程,自由下载转载，需注明出处]
原文：http://blog.csdn.net/tonny0832/article/details/19110831