function 的简单实现

template <typename R, typename Arg>  class  Invoker_Base
{
public:
    virtual  R  operator()(Arg arg) = 0;
};


template <typename R, typename Arg>  class  Function_Ptr_Invoker :
        public  Invoker_Base<R, Arg>
{
private:
    typedef  R (*FUNCTION_TYPE)(Arg);


public:
    Function_Ptr_Invoker(FUNCTION_TYPE  func)
        : m_func(func)
    {
    }


    R  operator ()(Arg arg)
    {
        return (*m_func)(arg);
    }


private:
    FUNCTION_TYPE  m_func;
};


template <typename R, typename Arg, typename T>  class Member_Ptr_Invoker :
        public Invoker_Base<R, Arg>
{
private:
    typedef  R (T::*MEM_FUNC)(Arg);


public:
    Member_Ptr_Invoker(T* object, MEM_FUNC  func)
        : m_func(func)
        , m_object(object)
    {
    }


    R  operator ()(Arg arg)
    {
        return (m_object->*m_func)(arg);
    }


private:
    MEM_FUNC   m_func;
    T*         m_object;
};


template <typename R, typename Arg, typename T>
class  Function_object_invoker : public Invoker_Base<R, Arg>
{
public:
    Function_object_invoker(T  t)
        : m_t(t)
    {


    }


    R  operator()(Arg arg)
    {
        return m_t(arg);
    }


private:
    T  m_t;
};


template <typename R, typename Arg>  class  Function1
{
private:
    typedef  R (*FUNC)(Arg);


public:
    Function1(FUNC func)
        : m_invoker(new  Function_Ptr_Invoker<R, Arg>(func))
    {
    }


    template <typename T>
    Function1(R (T::*mem_func)(Arg), T* object)
        : m_invoker(new Member_Ptr_Invoker<R, Arg, T>(object, mem_func))
    {
    }


    template <typename T>
    Function1(T t)
        : m_invoker(new Function_object_invoker<R, Arg, T>(t))
    {
    }


    ~Function1()
    {
        delete m_invoker;
    }


    R  operator ()(Arg arg)
    {
        return (*m_invoker)(arg);
    }


private:
    Invoker_Base<R, Arg>*  m_invoker;
};


bool  Some_Function(const std::string& str)
{
    printf("%s ", str.c_str());
    printf("this is normal function.\n");
}


class  Some_Func_Class
{
public:
    bool  Some_Memfunc(const std::string& str)
    {
        printf("%s ", str.c_str());
        printf("this is member function.\n");
    }
};


class  Some_Object_Class
{
public:
    bool  operator()(const std::string& str) const
    {
        printf("%s ", str.c_str());
        printf("this is object function.\n");
    }
};


void  FuncTest()
{
    Function1<bool, const string&>  func1(Some_Function);
    func1("hello world");


    Some_Func_Class  sc;
    Function1<bool, const string&>  func2(&Some_Func_Class::Some_Memfunc, &sc);
    func2("hello world");


    Some_Object_Class  so;
    Function1<bool, const string&>  func3(so);
    func3("hello world");


    Function1<bool, const string&>  func4(std::bind(&Some_Func_Class::Some_Memfunc, &sc, _1));
    func4("hello world");
}