C++ 指针函数、函数指针、回调函数
一、指针函数
是一个函数，只不过和一般函数区分的原因是它返回的是一个指针。
int* f ( int , int ) ; // 返回的是一个整形指针
int f ( int, int);// 返回的是一个整形数
上面两个区别的仅仅是返回值得不同，（注意顺便说下，返回值不同可不是重载函数，重载函数只根据形参的类型和个数，当然，只读函数const也是重载函数的判断依据）
当然，指针函数在使用时，必须与调用者的类型相同， 也就是说，返回值必须和左值的类型相同。
int * a = f (5,67) ; // 合法，类型相同
总结： 指针函数，比较容易懂，和一般函数的区别仅仅是返回值得不同，调用时注意返回的类型指针。
二、函数指针
是一个指针，只不过这个指针指向函数地址，他和其他函数名一样，具有（返回值类型，形参个数和类型）
int (*pFunc) (int , float) ; // 合法，定义了一个函数指针pFunc,该函数指针具有 返回int类型，同时带有两个形参，一个是int， 另一个是float;
我们可以简单理解为函数指针和一般的函数名一样，其实，一般情况下，函数名所代表的含义就是一个函数入口地址（指针）。
int getSum (int a, float b);
pFunc = getSum;//合法，函数名也可以理解为指针
pFunc = &getSum; // 合法，& 去地址符可以省略
int x = (*pFunc)(3,50) ;// 合法，使用函数指针调用时，我们需要用挂号将它包围使用，
三、回调函数
（1）Callback方式
Callback的本质是设置一个函数指针进去，然后在需要需要触发某个事件时调用该方法, 比如Windows的窗口消息处理函数就是这种类型。比如下面的示例代码，我们在Download完成时需要触发一个通知外面的事件：
#include
typedef void (__stdcall *DownloadCallback)(const char *pURL,bool OK);
void DownLoadFile(const char *pURL,DownloadCallback callback)
{
std::cout<<"downloading..."< (2)Sink方式
Sink的本质是你按照对方要求实现一个C++接口，然后把你实现的接口设置给对方，对方需要触发事件时调用该接口， COM中连接点就是居于这种方式。上面下载文件的需求，如果用Sink实现，代码如下:
//2. 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)
{
std::cout<<"downloading..."<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)
{
std::cout<<"onDownloadFinished..."<download();
system("pause");
} 小结：从上面的代码中可以看出，IDownloadSink 接口是一种约定，CMyDownloader 是接口的使用者，CMyFile是接口的实现者。他们两者之间是通过IDownloadSink 进行解耦的，使他们可以专注于自己的实现，接口的使用者CMyDownloader只管怎么使用接口的，接口怎么实现他不必关心；而接口的实现者IDownloadSink 他只管实现接口，接口怎么去用他不关心。维系两者关系的就是接口约定IDownloadSink 。
(3)Delegate方式
Delegate的本质是设置成员函数指针给对方，然后让对方在需要触发事件时调用。C#中用Delegate的方式实现Event，让C++程序员很是羡慕，C++中因为语言本身的关系，要实现Delegate还是很麻烦的。上面的例子我们用Delegate的方式实现如下:
class CDownloadDelegateBase
{
public:
virtual void Fire(const char* pURL, bool bOK) = 0;
};
template
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
CDownloadDelegate* MakeDelegate(O* pObject, void (T::*pFun)(const char* pURL, bool))
{
return new CDownloadDelegate(pObject, pFun);
}
class CDownloadEvent
{
public:
~CDownloadEvent()
{
vector::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 m_arDelegates;
typedef vector::iterator ITR;
};
class CMyDownloaderEx
{
public:
void DownloadFile(const char* pURL)
{
cout << "downloading: " << pURL << "" << 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++
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;
} 第二个实例：将PlayerRelay中的数据在Player中进行处理。
#ifndef PLAYERRELAY_H
#define PLAYERRELAY_H
#include
//声明函数指针
typedef void(*ts_data_input_t)(void* user, char* s, int length);
class PlayerRelay
{
public:
void setCbk(ts_data_input_t ts_data_input, void* user);//注册回调函数
void transport_data(); //数据输出函数，这里会调用Plyer中的回调函数ts_data_input(void* user,char* s,int length)
public:
PlayerRelay();
~PlayerRelay();
ts_data_input_t m_ts_data_input;
void* user;
};
#endif
#include "playerRelay.h"
PlayerRelay::PlayerRelay()
{
}
PlayerRelay::~PlayerRelay()
{
}
void PlayerRelay::setCbk(ts_data_input_t ts_data_input, void* user)
{
std::cout << "注册回调函数" << std::endl;
this->m_ts_data_input = ts_data_input;
this->user = user;
}
void PlayerRelay::transport_data()
{
std::cout << "PlayerRelay::transport_data" << std::endl;
char* s = "asdfg";
if (m_ts_data_input)
{
m_ts_data_input(user, s, 5);
}
}
#ifndef PLAYER_H
#define PLAYER_H
#include
#include "playerRelay.h"
class Player
{
public:
static void ts_data_input(void* user, char * s, int length);//回调函数，一般设置为static
void ts_data_input_in(char* s, int length); //该函数处理PlayerRelay中的数据。
public:
Player();
~Player();
};
#endif
#include "player.h"
Player::Player()
{
PlayerRelay playerRelay;
playerRelay.setCbk(ts_data_input, this); //注册回调函数，将ts_data_input和当前类注册到类PlayerRelay中
playerRelay.transport_data(); //在该函数中将数据作为参数传入ts_data_input(。。。)中，最终在当前类中实现数据的处理
}
Player::~Player()
{
}
/**回调函数**/
void Player::ts_data_input(void* user,char* s,int length) //传过来的参数user其实就是将player传到PlayerRelay在通过ts_data_input传过来
{
std::cout << "回调函数:--->Player::ts_data_input" << std::endl;
Player *pthis = (Player*)user;
pthis->ts_data_input_in(s, length);
}
void Player::ts_data_input_in(char* s, int length)
{
std::cout << "处理数据Player::ts_data_input_in" << std::endl;
std::cout << s << std::endl;
std::cout << length << std::endl;
std::cout << "do with data!" << std::endl;
}
int main()
{
Player player;
getchar();
return 0;
}
最后简单比较下上面3种实现回调的方法:
第一种Callback的方法是面向过程的，使用简单而且灵活，正如C语言本身。
第二种Sink的方法是面向对象的，在C++里使用较多， 可以在一个Sink里封装一组回调接口，适用于一系列比较固定的回调事件。
第三种Delegate的方法也是面向对象的，和Sink封装一组接口不同，Delegate的封装是以函数为单位，粒度比Sink更小更灵活。