In that case, I'll throw in another, better example:

Code:

class ExClass
{
public:
int func(const int& z); //***
};
int ExClass::func(const int& z) { return z; }
template<typename Class_t, typename Fnc_t, typename Return_t>
class Functor
{
public:
Functor(Class_t& Class, Fnc_t FncPtr): m_Class(Class), m_FncPtr(FncPtr) { }
Return_t operator () { return m_FncPtr(); }
const Return_t operator () const { return m_FncPtr(); }
private:
Class_t m_Class;
Fnc_t m_FncPtr;
};
template<typename Return_t, typename Class_t, typename Fnc_t>
Functor<Class_t, Fnc_t, Return_t> FunctorWrapper(Class_t& Class, Fnc_t FncPtr)
{
return Functor<Class_t, Fnc_t, Return_t>(Class, FncPtr);
}
template<typename T> void example(T& Functor) { Functor(); }
int main()
{
ExClass f;
example( FunctorWrapper<int>(f, &ExClass::func) );
return 0;
}

I'm not sure how it handles void return type, however. It may be that it needs extra work. Perhaps a specialization.