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

（1）Callback方式
Callback的本质是设置一个函数指针进去，然后在需要需要触发某个事件时调用该方法, 比如Windows的窗口消息处理函数就是这种类型。

比如下面的示例代码，我们在Download完成时需要触发一个通知外面的事件：

typedefvoid(__stdcall*DownloadCallback)(constchar*pURL,boolbOK);
voidDownloadFile(constchar*pURL,DownloadCallbackcallback)
{
cout<<"downloading:"<<pURL<<""<<endl;
callback(pURL,true);
}
void__stdcallOnDownloadFinished(constchar*pURL,boolbOK)
{
cout<<"OnDownloadFinished,URL:"<<pURL<<"status:"<<bOK<<endl;
}

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

上面下载文件的需求，如果用Sink实现，代码如下:

classIDownloadSink
{
public:
virtualvoidOnDownloadFinished(constchar*pURL,boolbOK)=0;
};
classCMyDownloader
{
public:
CMyDownloader(IDownloadSink*pSink)
:m_pSink(pSink)
{
}

voidDownloadFile(constchar*pURL)
{
cout<<"downloading:"<<pURL<<""<<endl;
if(m_pSink!=NULL)
{
m_pSink->OnDownloadFinished(pURL,true);
}
}

private:
IDownloadSink*m_pSink;
};

classCMyFile:publicIDownloadSink
{
public:
voiddownload()
{
CMyDownloaderdownloader(this);
downloader.DownloadFile("www.baidu.com");
}

virtualvoidOnDownloadFinished(constchar*pURL,boolbOK)
{
cout<<"OnDownloadFinished,URL:"<<pURL<<"status:"<<bOK<<endl;
}
};

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

classCDownloadDelegateBase
{
public:
virtualvoidFire(constchar*pURL,boolbOK)=0;
};

template<typenameO,typenameT>
classCDownloadDelegate:publicCDownloadDelegateBase
{
typedefvoid(T::*Fun)(constchar*,bool);
public:
CDownloadDelegate(O*pObj=NULL,FunpFun=NULL)
:m_pFun(pFun),m_pObj(pObj)
{
}

virtualvoidFire(constchar*pURL,boolbOK)
{
if(m_pFun!=NULL
&&m_pObj!=NULL)
{
(m_pObj->*m_pFun)(pURL,bOK);
}
}

private:
Funm_pFun;
O*m_pObj;
};

template<typenameO,typenameT>
CDownloadDelegate<O,T>*MakeDelegate(O*pObject,void(T::*pFun)(constchar*pURL,bool))
{
returnnewCDownloadDelegate<O,T>(pObject,pFun);
}

classCDownloadEvent
{
public:
~CDownloadEvent()
{
vector<CDownloadDelegateBase*>::iteratoritr=m_arDelegates.begin();
while(itr!=m_arDelegates.end())
{
delete*itr;
++itr;
}
m_arDelegates.clear();
}

voidoperator+=(CDownloadDelegateBase*p)
{
m_arDelegates.push_back(p);
}

voidoperator-=(CDownloadDelegateBase*p)
{
ITRitr=remove(m_arDelegates.begin(),m_arDelegates.end(),p);

ITRitrTemp=itr;
while(itrTemp!=m_arDelegates.end())
{
delete*itr;
++itr;
}
m_arDelegates.erase(itr,m_arDelegates.end());
}

voidoperator()(constchar*pURL,boolbOK)
{
ITRitrTemp=m_arDelegates.begin();
while(itrTemp!=m_arDelegates.end())
{
(*itrTemp)->Fire(pURL,bOK);
++itrTemp;
}
}

private:
vector<CDownloadDelegateBase*>m_arDelegates;
typedefvector<CDownloadDelegateBase*>::iteratorITR;
};


classCMyDownloaderEx
{
public:
voidDownloadFile(constchar*pURL)
{
cout<<"downloading:"<<pURL<<""<<endl;
downloadEvent(pURL,true);
}

CDownloadEventdownloadEvent;
};

classCMyFileEx
{
public:
voiddownload()
{
CMyDownloaderExdownloader;
downloader.downloadEvent+=MakeDelegate(this,&CMyFileEx::OnDownloadFinished);
downloader.DownloadFile("www.baidu.com");
}

virtualvoidOnDownloadFinished(constchar*pURL,boolbOK)
{
cout<<"OnDownloadFinished,URL:"<<pURL<<"status:"<<bOK<<endl;
}
};

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


我们可以用下面的代码测试我们上面的实现：

int_tmain(intargc,_TCHAR*argv[])
{

DownloadFile("www.baidu.com",OnDownloadFinished);

CMyFilef1;
f1.download();

CMyFileExff;
ff.download();

system("pause");

return0;
}

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

你更倾向于用哪种方式来实现回调?