回调的本质是以某种形式持有被调用者，被调用者可以是函数名、函数指针、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<std::string, PFUNC> 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<std::string, IFace*> 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<std::string, CCaller*> m_mapCmdCaller;
};
在以上用法中，被回调者都是直接被执行者，这是什么意思呢？
这就是说被回调者本身处理了最终的代码执行。这种做法有个缺点，我们继续往下看。
在很多软件工程场景中，有类似执行一组命令的使用情况。如果我们要把这组命令做成回调，采用上面的三种方法，都需要编制一组被调用者。
尤其是对基类指针和函数对象来说，为了能够成为被回调者，不得不额外地做很多的工作，甚至是破坏原来的代码，使之成为一组派生者和函数对象。
为了解决这个问题，下面我们介绍一种新方法：模板封装。
基于基类的模板封装：
// 被调用者基类
class ICaller
{
public:
virtual ~ICaller() {}
virtual void doIt(int nVal) = 0;
};
// 被调用者基类模板封装
template<typename C, void (C::*f)(int nVal)>
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<std::string, ICaller*> 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<CApp, &CApp::cmd1> caller1(&app);
TBindCaller<CApp, &CApp::cmd2> caller2(&app);
CHolder holder;
holder.setCaller("cmd1", &caller1);
holder.setCaller("cmd2", &caller2);
holder.doCaller("cmd1", 1);
holder.doCaller("cmd2", 1);
return 0;
}
基于函数对象的模板封装：
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <map>
#include <string>
// 被调用者函数对象模板封装
template<typename C>
class TBindCaller
{
typedef void (C::*PF)(int nVal);
public:
TBindCaller(C* p, PF f) : m_pClass(p), m_f(f) {}
void operator() (int nVal)
{
(m_pClass->*m_f)(nVal);
}
private:
C* m_pClass;
PF m_f;
};
// 被封装的执行者
class CApp
{
public:
void cmd1(int nVal)
{
printf("@CApp::cmd1 %d \n", nVal);
}
void cmd2(int nVal)
{
printf("@CApp::cmd2 %d \n", nVal);
}
};
// 调用者：
class CHolder
{
public:
// 设置多个被调用者
void setCaller(const std::string& strCmd, TBindCaller<CApp>* pCaller)
{
m_mapCmdCaller[strCmd] = pCaller;
}
// 向具体的被调用者发起回调
void doCaller(const std::string& strCmd, int nVal)
{
(*m_mapCmdCaller[strCmd])(nVal);
}
private:
// 持有一组被调用者
std::map<std::string, TBindCaller<CApp>* > m_mapCmdCaller;
};
int main(int argc, char* argv[])
{
CApp app;
TBindCaller<CApp> caller1(&app, &CApp::cmd1);
TBindCaller<CApp> caller2(&app, &CApp::cmd2);
CHolder holder;
holder.setCaller("cmd1", &caller1);
holder.setCaller("cmd2", &caller2);
holder.doCaller("cmd1", 1);
holder.doCaller("cmd2", 1);
return 0;
}
bind&function模板封装：
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <functional>
#include <string>
#include <map>
// 被封装的执行者
class CApp
{
public:
void cmd1(int nVal)
{
printf("@CApp::cmd1 %d \n", nVal);
}
void cmd2(int nVal)
{
printf("@CApp::cmd2 %d \n", nVal);
}
};
// 调用者：
class CHolder
{
public:
// 设置多个被调用者
void setCaller(const std::string& strCmd, std::function<void(int)> Caller)
{
m_mapCmdCaller[strCmd] = Caller;
}
// 向具体的被调用者发起回调
void doCaller(const std::string& strCmd, int nVal)
{
(m_mapCmdCaller[strCmd])(nVal);
}
private:
// 持有一组被调用者
std::map<std::string, std::function<void(int)> > m_mapCmdCaller;
};
int main(int argc, char* argv[])
{
CApp app;
CHolder holder;
holder.setCaller("cmd1", std::bind(&CApp::cmd1, &app, std::placeholders::_1));
holder.setCaller("cmd2", std::bind(&CApp::cmd2, &app, std::placeholders::_1));
holder.doCaller("cmd1", 1);
holder.doCaller("cmd2", 2);
return 0;
}
