C++中实现回调机制的几种方式

╰+攻爆jí腚メ 2022-03-30 04:22 213阅读 0赞

转自：[http://www.cppblog.com/weiym/archive/2012/08/28/188515.html][http_www.cppblog.com_weiym_archive_2012_08_28_188515.html]

（1）Callback方式  
Callback的本质是设置一个函数指针进去，然后在需要需要触发某个事件时调用该方法, 比如Windows的窗口消息处理函数就是这种类型。  
  
比如下面的示例代码，我们在Download完成时需要触发一个通知外面的事件：

typedef void (\_\_stdcall \*DownloadCallback)( const char\* pURL, bool bOK);  
void DownloadFile( const char\* pURL, DownloadCallback callback)  
\{  
cout << "downloading: " << pURL << " ![dot.gif][]" << endl;  
callback(pURL, true);  
\}  
void \_\_stdcall OnDownloadFinished( const char\* pURL, bool bOK)  
\{  
cout << "OnDownloadFinished, URL:" << pURL << " status:" << bOK << endl;  
\}

(2)Sink方式  
Sink的本质是你按照对方要求实现一个C++接口，然后把你实现的接口设置给对方，对方需要触发事件时调用该接口， COM中连接点就是居于这种方式。  
  
上面下载文件的需求，如果用Sink实现，代码如下:

class IDownloadSink  
\{  
public:  
virtual void OnDownloadFinished( const char\* pURL, bool bOK) = 0;  
\};  
class CMyDownloader  
\{  
public:  
CMyDownloader(IDownloadSink\* pSink)  
:m\_pSink(pSink)  
\{  
\}  
  
void DownloadFile( const char\* pURL)  
\{  
cout << "downloading: " << pURL << " ![dot.gif][]" << endl;  
if(m\_pSink != NULL)  
\{  
m\_pSink->OnDownloadFinished(pURL, true);  
\}  
\}  
  
private:  
IDownloadSink\* m\_pSink;  
\};  
  
class CMyFile: public IDownloadSink  
\{  
public:  
void download()  
\{  
CMyDownloader downloader( this);  
downloader.DownloadFile("www.baidu.com");  
\}  
  
virtual void OnDownloadFinished( const char\* pURL, bool bOK)  
\{  
cout << "OnDownloadFinished, URL:" << pURL << " status:" << bOK << endl;  
\}  
\};

(3)Delegate方式  
Delegate的本质是设置成员函数指针给对方，然后让对方在需要触发事件时调用。  
C\#中用Delegate的方式实现Event，让C++程序员很是羡慕，C++中因为语言本身的关系，要实现Delegate还是很麻烦的。  
上面的例子我们用Delegate的方式实现如下:

class CDownloadDelegateBase  
\{  
public:  
virtual void Fire( const char\* pURL, bool bOK) = 0;  
\};  
  
template<typename O, typename T>  
class CDownloadDelegate: public CDownloadDelegateBase  
\{  
typedef void (T::\*Fun)( const char\*, bool);  
public:  
CDownloadDelegate(O\* pObj = NULL, Fun pFun = NULL)  
:m\_pFun(pFun), m\_pObj(pObj)  
\{  
\}  
  
virtual void Fire( const char\* pURL, bool bOK)  
\{  
if(m\_pFun != NULL  
&& m\_pObj != NULL)  
\{  
(m\_pObj->\*m\_pFun)(pURL, bOK);  
\}  
\}  
  
private:  
Fun m\_pFun;  
O\* m\_pObj;  
\};  
  
template<typename O, typename T>  
CDownloadDelegate<O,T>\* MakeDelegate(O\* pObject, void (T::\*pFun)( const char\* pURL, bool))  
\{  
return new CDownloadDelegate<O, T>(pObject, pFun);  
\}  
  
class CDownloadEvent  
\{  
public:  
~CDownloadEvent()  
\{  
vector<CDownloadDelegateBase\*>::iterator itr = m\_arDelegates.begin();  
while (itr != m\_arDelegates.end())  
\{  
delete \*itr;  
\++itr;  
\}  
m\_arDelegates.clear();  
\}  
  
void operator \+= (CDownloadDelegateBase\* p)  
\{  
m\_arDelegates.push\_back(p);  
\}  
  
void operator \-= (CDownloadDelegateBase\* p)  
\{  
ITR itr = remove(m\_arDelegates.begin(), m\_arDelegates.end(), p);  
  
ITR itrTemp = itr;  
while (itrTemp != m\_arDelegates.end())  
\{  
delete \*itr;  
\++itr;  
\}  
m\_arDelegates.erase(itr, m\_arDelegates.end());  
\}  
  
void operator()( const char\* pURL, bool bOK)  
\{  
ITR itrTemp = m\_arDelegates.begin();  
while (itrTemp != m\_arDelegates.end())  
\{  
(\*itrTemp)->Fire(pURL, bOK);  
\++itrTemp;  
\}  
\}  
  
private:  
vector<CDownloadDelegateBase\*> m\_arDelegates;  
typedef vector<CDownloadDelegateBase\*>::iterator ITR;  
\};  
  
  
class CMyDownloaderEx  
\{  
public:  
void DownloadFile( const char\* pURL)  
\{  
cout << "downloading: " << pURL << " ![dot.gif][]" << endl;  
downloadEvent(pURL, true);  
\}  
  
CDownloadEvent downloadEvent;  
\};  
  
class CMyFileEx  
\{  
public:  
void download()  
\{  
CMyDownloaderEx downloader;  
downloader.downloadEvent += MakeDelegate( this, &CMyFileEx::OnDownloadFinished);  
downloader.DownloadFile("www.baidu.com");  
\}  
  
virtual void OnDownloadFinished( const char\* pURL, bool bOK)  
\{  
cout << "OnDownloadFinished, URL:" << pURL << " status:" << bOK << endl;  
\}  
\};

可以看到Delegate的方式代码量比上面其他2种方式大多了，并且我们上面是固定参数数量和类型的实现方式，如果要实现可变参数，要更加麻烦的多。  
可变参数的方式可以参考这2种实现:  
[Yet Another C\#-style Delegate Class in Standard C++  
][Yet Another C_-style Delegate Class in Standard C_] [Member Function Pointers and the Fastest Possible C++ Delegates][Member Function Pointers and the Fastest Possible C_ Delegates]  
  
  
我们可以用下面的代码测试我们上面的实现：

int \_tmain( int argc, \_TCHAR\* argv\[\])  
\{  
  
DownloadFile("www.baidu.com", OnDownloadFinished);  
  
CMyFile f1;  
f1.download();  
  
CMyFileEx ff;  
ff.download();  
  
system("pause");  
  
return 0;  
\}

最后简单比较下上面3种实现回调的方法:  
第一种Callback的方法是面向过程的，使用简单而且灵活，正如C语言本身。  
第二种Sink的方法是面向对象的，在C++里使用较多， 可以在一个Sink里封装一组回调接口，适用于一系列比较固定的回调事件。  
第三种Delegate的方法也是面向对象的，和Sink封装一组接口不同，Delegate的封装是以函数为单位，粒度比Sink更小更灵活。  
  
你更倾向于用哪种方式来实现回调?

注：

1.\_\_event/\_\_raise/\_\_hook 机制，和C\#的event同样用法。  
2.C++ 0x11支持的lambda表达式和function类（也可以用boost的function），可以替代一切回调。 我现在基本用这种方法。

这么多方法实现回调，只不过是万变不离其宗罢了。

多种需求的多种变化，想想确实十分精妙。

[http_www.cppblog.com_weiym_archive_2012_08_28_188515.html]: http://www.cppblog.com/weiym/archive/2012/08/28/188515.html
[dot.gif]: /images/20220330/9ba91e9adaa54a5ab66662b701098ef1.png
[Yet Another C_-style Delegate Class in Standard C_]: http://www.codeproject.com/Articles/11464/Yet-Another-C-style-Delegate-Class-in-Standard-C
[Member Function Pointers and the Fastest Possible C_ Delegates]: http://www.codeproject.com/Articles/7150/Member-Function-Pointers-and-the-Fastest-Possible