c++回调实现

回调是A将一个函数指针传给B，然后调用B，B在执行自身函数后，再在合适的时候执行A的这个函数指针，这样就能避免A和B的相互包含和链接，在大型项目中回调是一种打破循环依赖的常用技术。

typedef void(CALLBACK* MyCallBack)(const char *);
typedef void(*MyFuncB)(MyCallBack, const char *);

//回调函数
void CALLBACK FuncC(const char* pszStr)
{
    std::cout << "FunC is Running" << std::endl;
    if (!pszStr)
    {
        return;
    }
    std::cout << pszStr << std::endl;
}

//设置回调，并且执行FuncB
void FuncA(MyFuncB pFunB, MyCallBack pCallBAck, const char * pszStr)
{
    std::cout << "FunA is Running" << std::endl;
    if (pCallBAck && pFunB)
    {
        pFunB(pCallBAck, pszStr);
    }
}

void FunB(MyCallBack pCallBAck, const char * pszStr)
{
    std::cout << "FunB is Running" << std::endl;
    if (pCallBAck)
    {
        pCallBAck(pszStr);
    }
}

void FuncD(void)
{
    std::cout << "FunD is Running" << std::endl;
}

class  CTestA
{
public:
    void SetCallBack(MyCallBack pCallBack,const char* pszStr)
    {
        std::cout << "SetCallBack" << std::endl;
        if (pCallBack && pszStr)
        {
            m_pCallBack = pCallBack;
            m_pszStr = (char*)pszStr;
        }
        DoCallBack();
    }

    void DoCallBack()
    {
        std::cout << "DoCallBack Running" << std::endl;
        if (m_pCallBack)
        {
            m_pCallBack(m_pszStr);
        }
    }

private:
    MyCallBack m_pCallBack;
    char* m_pszStr;
};

class CTestB
{
public:
    void static CALLBACK FuncCallBack(const char* pszStr)//非 static比较麻烦
    {
        if (pszStr)
        {
            std::cout << pszStr << std::endl;
        }

    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    FuncA(FunB, FuncC,"hello");
    FuncD();

    CTestA a;
    a.SetCallBack(CTestB::FuncCallBack, "hello");

    return ;
}

boost::bind也能实现类似功能