共享一下自己n年前写的仿函数，希望对大家有用！

template
<
class R  = void,
class T1 = void,
class T2 = void,
class T3 = void,
class T4 = void,
class T5 = void
> 
class Functor;

 

#define NEW_FUNCTOR(TFunctor,T,pT,mfun) TFunctor::New<T,mfun>(pT)
#define NEW_FUNCTOR_CONST(TFunctor,T,pT,mfun) TFunctor::NewConst<T,mfun>(pT)

 

template<class R>
class Functor<R,void,void,void,void,void>
{
public:
typedef R R;
typedef Functor<R,void,void,void,void,void> MyFunctor;
typedef R (Functor::*MemFun)();

private:
MemFun mpMF;
void* mp;

public:
R NullFun()
{
Warning("NullFun");
}

Functor(MemFun pMF = &MyFunctor::NullFun , void* pT = 0)
:mpMF(pMF)
,mp(pT)
{
}

template<class T, R (T::*MemFun)()>
inline static MyFunctor New(T* pT)
{
return MyFunctor(&MemFunctorImpl<T,MemFun>,pT);
}

template<class T, R (T::*MemFun)() const>
inline static MyFunctor NewConst(T* pT)
{
return MyFunctor(&MemFunctorConstImpl<T,MemFun>,pT);
}

template<R (*Fun)()>
R FunctorImpl()
{
return Fun();
}

template<class T,  R (T::*MemFun)()>
R MemFunctorImpl()
{
T* pT = (T*)mp;
return ((*pT).*MemFun)();
}

template<class T,  R (T::*MemFun)() const>
R MemFunctorConstImpl()
{
T* pT = (T*)mp;
return ((*pT).*MemFun)();
}

//
R operator()()
{
return ((*this).*mpMF)();
}

    bool operator==(const MyFunctor& rhs) const
    { return (this->mpMF == rhs.mpMF && this->mp == rhs.mp); }

operator bool() const
{ return mpMF != &MyFunctor::NullFun; }

};

template<class R,class T1>
class Functor<R,T1,void,void,void,void>
{
public:
typedef R R;
typedef T1 T1;

typedef Functor<R,T1,void,void,void,void> MyFunctor;
typedef R (Functor::*MemFun)(T1);

private:
MemFun mpMF;
void* mp;

public:
R NullFun(T1)
{
Warning("NullFun");
}

Functor(MemFun pMF = &MyFunctor::NullFun , void* pT = 0)
:mpMF(pMF)
,mp(pT)
{
}

template<class T, R (T::*MemFun)(T1)>
inline static MyFunctor New(T* pT)
{
return MyFunctor(&MemFunctorImpl<T,MemFun>,pT);
}

template<class T, R (T::*MemFun)(T1)const>
inline static MyFunctor NewConst(T* pT)
{
return MyFunctor(&MemFunctorConstImpl<T,MemFun>,pT);
}

template<R (*Fun)(T1)>
R FunctorImpl(T1 t1)
{
return Fun(t1);
}

template<class T,  R (T::*MemFun)(T1)>
R MemFunctorImpl(T1 t1)
{
T* pT = (T*)mp;
return ((*pT).*MemFun)(t1);
}

template<class T,  R (T::*MemFun)(T1)const>
R MemFunctorConstImpl(T1 t1)
{
T* pT = (T*)mp;
return ((*pT).*MemFun)(t1);
}

R operator()(T1 t1)
{
return ((*this).*mpMF)(t1);
}

    bool operator==(const MyFunctor& rhs) const
    { return (this->mpMF == rhs.mpMF && this->mp == rhs.mp); }

operator bool() const
{ return mpMF != &MyFunctor::NullFun; }

};

... ...

///////////////////////////////////////////////////////////////////////////////////////
//main.cpp
#include <iostream>

class C
{
public:
void fun(int)
{
std::cout << "call C::fun(int)";
}
};

typedef Functor<void,int> CFun;

void main()
{
C c;

CFun f = CFun::New<C,&C::fun>(&c);

f(0); //call C::fun(int)

}

用起来很简单，我也不多说了。
如果大家原来对仿函数就有研究的，就可以看出这和其他lib提供的仿函数有什么区别了。