c/c++回调技术总结

回调的本质是以某种形式持有被调用者，被调用者可以是函数名、函数指针、c++接口对象指针、函数对象。并且视软件逻辑的要求，在相应的条件触发时，以某种方法调用被调用者。

回调技术需要解决两个核心问题：
1.如何持有被调用者？
2.如何调用被调用者？
下面将围绕这两个问题，但是我想换个角度，从被调用者出发，分别阐述如何持有和如何调用。

函数名：

函数名表示一个函数的入口地址，它的地址由编译器在编译和链接时决定，而且是固定不变的。从使用的场景来看，持有函数名来做为被调用者，这就是非常普通的函数调用。严格意义上来说，这其实算不上回调，调用者持有被调用者的函数名，这是一种硬编码的行为，两者之间有强烈的耦合关系。

这里我重新给回调下一个比较容易接受的定义：调用者与被调用者不耦合，它们之间只按某种相同的调用规范，由调用者动态地持用被调用者，并且向被调用者发起调用。

函数指针：

函数指针是一个变量，它用来保存具体的函数地址。使用函数指针可以解耦调用者与被调用者，满足动态持有与动态调用。

由于c++的封装性，个人觉得使用c++对象演示更容易理解，所以本文代码（伪代码）全部基于c++。

例子1：

定义函数指针类型：
typedef void (*PFUNC)(int);

调用者：
class CHolder
{
public:
    CHolder() : m_pCaller(NULL) {}
    virtual ~CHolder() {}

    // 设置单个被调用者
    void setCaller(PFUNC pCaller) { m_pCaller = pCaller; }
    // 向单个被调用者发起回调
    void doFuncCaller(int nVal) { m_pCaller(nVal); }

private:
    // 持有单个被调用者
    PFUNC m_pCaller;
};

例子2：

调用者：
class CHolder
{
public:
    CHolder()  {}
    virtual ~CHolder() {}

    // 设置多个被调用者
    void setCaller(const std::string& strCmd, PFUNC pCaller)
    {
        m_mapCmdCaller[strCmd] = pCaller
    }
    // 向具体的被调用者发起回调
    void doCaller(const std::string& strCmd, int nVal)
    {
        m_mapCmdCaller[strCmd](nVal);
    }

private:
    // 持有一组被调用者
    std::map m_mapCmdCaller;
};

c++接口对象指针：

c++接口是一个c++基类的抽象定义，它定义类的方法的调用规范，派生类可以从它继承，分别实现不同的代码逻辑，因而c++接口技术也广泛应用于回调场景。

把上面的两个例子直接换成c++接口，代码（伪代码）如下：

例子1：

定义c++接口基类：
class IFace
{
public:
    virtual ~IFace() {}
    virtual void doIt(int nVal) = 0;
};

被调用者：
class CCaller : public IFace
{
public:
    virtual void doIt(int nVal) 
    {
        代码
    }
};

调用者：
class CHolder
{
public:
    CHolder() : m_pCaller(NULL) {}
    virtual ~CHolder() {}

    // 设置单个被调用者
    void setCaller(IFace* pCaller) { m_pCaller = pCaller; }
    // 向单个被调用者发起回调
    void doCaller(int nVal) { m_pCaller->doIt(nVal); }

private:
    // 持有单个被调用者
    IFunc* m_pCaller;
};

例子2：

调用者：
class CHolder
{
public:
    CHolder() {}
    virtual ~CHolder() {}

    // 设置多个被调用者
    void setCaller(const std::string& strCmd, IFace* pCaller)
    {
        m_mapCmdCaller[strCmd] = pCaller;
    }
    // 向具体的被调用者发起回调
    void doCaller(const std::string& strCmd, int nVal)
    {
        m_mapCmdCaller[strCmd]->doIt(nVal);
    }

private:
    // 持有一组被调用者
    std::map m_mapCmdCaller;
};

此外，还要说明的是，c++接口与普通函数指针相比，它还可以采用模板技术包装不同的第三方类和成员方法，因而也较多的应用于回调场景。使用方法如下：

函数对象：

通过对某个类重载调用操作符，使其对象可以像函数一样调用，这样的对象称为函数对象，又称仿函数。并且调用操作符的参数是不固定的，因此函数对象也被广泛地应用于回调场景。

把上面的两个例子直接换成c++接口，代码（伪代码）如下：

例子1：

被调用者：
class CCaller
{
public:
    CCaller() {}
    virtual ~CCaller() {}

    void operator()(int nVal) {
        代码
    }
};

调用者：
class CHolder
{
public:
    CHolder() : m_pCaller(NULL) {}
    virtual ~CHolder() {}

    // 设置单个被调用者
    void setCaller(CCaller* pCaller) { m_pCaller = pCaller; }
    // 向单个被调用者发起回调
    void doCaller(int nVal) { (*m_pCaller)(nVal); }

private:
    // 持有单个被调用者
    CCaller* m_pCaller;
};

例子2：

调用者：
class CHolder
{
public:
    CHolder() {}
    virtual ~CHolder() {}

    // 设置多个被调用者
    void setCaller(const std::string& strCmd, CCaller* pCaller)
    {
        m_mapCmdCaller[strCmd] = pCaller;
    }
    // 向具体的被调用者发起回调
    void doCaller(const std::string& strCmd, int nVal)
    {
        (*m_mapCmdCaller[strCmd])(nVal);
    }

private:
    // 持有一组被调用者
    std::map m_mapCmdCaller;
};

在以上用法中，被回调者都是直接被执行者，这是什么意思呢？
这就是说被回调者本身处理了最终的代码执行。这种做法有个缺点，我们继续往下看。

在很多软件工程场景中，有类似执行一组命令的使用情况。如果我们要把这组命令做成回调，采用上面的三种方法，都需要编制一组被调用者。
尤其是对基类指针和函数对象来说，为了能够成为被回调者，不得不额外地做很多的工作，甚至是破坏原来的代码，使之成为一组派生者和函数对象。
为了解决这个问题，下面我们介绍一种新方法：模板封装。

基于基类的模板封装：

// 被调用者基类
class ICaller
{
public:
    virtual ~ICaller() {}
    virtual void doIt(int nVal) = 0;
};

// 被调用者基类模板封装
template
class TBindCaller
    : public ICaller
{
public:
    TBindCaller(C* p) : m_pClass(p) {}

    virtual void doIt(int nVal)
    {
        (m_pClass->*f)(nVal);
    }

private:
    C* m_pClass;
};

// 调用者：
class CHolder
{
public:
    CHolder() {}
    virtual ~CHolder() {}

    // 设置多个被调用者
    void setCaller(const std::string& strCmd, ICaller* pCaller)
    {
        m_mapCmdCaller[strCmd] = pCaller;
    }
    // 向具体的被调用者发起回调
    void doCaller(const std::string& strCmd, int nVal)
    {
        (m_mapCmdCaller[strCmd]->doIt)(nVal);
    }

private:
    // 持有一组被调用者
    std::map m_mapCmdCaller;
};

// 被封装的执行者
class CApp
{
public:

    void cmd1(int nVal)
    {
        printf("@CApp::cmd1 %d \n", nVal);
    }
    void cmd2(int nVal)
    {
        printf("@CApp::cmd2 %d \n", nVal);
    }
};

int main(int argc, char* argv[])
{
    CApp app;
    TBindCaller caller1(&app);
    TBindCaller caller2(&app);

    CHolder holder;
    holder.setCaller("cmd1", &caller1);
    holder.setCaller("cmd2", &caller2);

    holder.doCaller("cmd1", 1);
    holder.doCaller("cmd2", 1);

    return 0;
}

基于函数对象的模板封装：

#include 
#include 
#include 
#include 

bind&function模板封装：

#include 
#include 
#include 

#include 
#include 
#include