function 的简单实现

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


template  class  Function_Ptr_Invoker :
        public  Invoker_Base
{
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  class Member_Ptr_Invoker :
        public Invoker_Base
{
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
class  Function_object_invoker : public Invoker_Base
{
public:
    Function_object_invoker(T  t)
        : m_t(t)
    {


    }


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


private:
    T  m_t;
};


template  class  Function1
{
private:
    typedef  R (*FUNC)(Arg);


public:
    Function1(FUNC func)
        : m_invoker(new  Function_Ptr_Invoker(func))
    {
    }


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


    template
    Function1(T t)
        : m_invoker(new Function_object_invoker(t))
    {
    }


    ~Function1()
    {
        delete m_invoker;
    }


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


private:
    Invoker_Base*  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  func1(Some_Function);
    func1("hello world");


    Some_Func_Class  sc;
    Function1  func2(&Some_Func_Class::Some_Memfunc, &sc);
    func2("hello world");


    Some_Object_Class  so;
    Function1  func3(so);
    func3("hello world");


    Function1  func4(std::bind(&Some_Func_Class::Some_Memfunc, &sc, _1));
    func4("hello world");
}