C++的回调函数的简单实现

在网络消息处理中经常要用到回调机制,有的是来处理异步网络数据通信问题(摄器模式),有的是来处理订阅问题(观察者模式)。

在C/C++开发用用的很多,一下是一些简单的例子(部分例子代码不全,需自行补全)

一、C的回调函数是比较简单的，

例如： 

int myFunction(int num)

{
printf("myFunction num:%d\n",num);
return -1;

}

//定义FUNC类型是一个指向函数的指针

//params[in]为int类型

//return为int类型

typedef int (*FUNC)(int);

int _tmain(int argc, _TCHAR* argv[])

{
FUNC callback = (FUNC)&myFunction;
int num = 10;
callback(10);
return 0;

}

执行结果：myFunction num:10

二、对于C++来说如何实现回调函数呢？

1、最原始的方法我们可以在类外定义全局的函数实现回调，参数上通过传递this指针来达到处理当前对象的一些业务。

例如：

typedef bool (*FUNC1)(void* pCFunc);

bool onGetFunName(void* pCFunc)

{
if(pCFunc != NULL)
{
CFunc* fuc = (CFunc*)pCFunc;
bool ret = fuc->getName();
printf("name is:%d\n", ret);
return true;
}
return false;

}

CFunc::CFunc(void)

{

}

CFunc::~CFunc(void)

{

}

bool CFunc::getName()

{
printf("getName ");
return true;

}

bool CFunc::showName()

{
FUNC1 callback = (FUNC1)&onGetFunName;
return onGetFunName(this);

}

执行结果：getName name is:1

2、一般来说我们更想让对象之前共享一个回调函数，所以很多时候用类函数来实现回调函数，例如我们一个简单的线程测试类：

//***************************************************************//

class MyThread

{

public:
MyThread(void);
~MyThread(void);

int init();

int destory();

//定义成static的类函数,此时类函数里无法操作对象私有变量
static void* __stdcall threadBody(void* arg);
static void* __stdcall producer(void* arg);

int creatProduct();
int creatConsumer();

};

/************************************************************/

static hpr_sem g_Semaphore(0);

static hpr_mutex g_mutex;

static TaskQueMgr g_MsgQ;

MyThread::MyThread(void)

{

}

MyThread::~MyThread(void)

{

}

int MyThread::init()

{
return 0;

}

int MyThread::destory()

{
//线程结束
HPR_Thread_Exit();
return 0;

}

void* __stdcall MyThread::threadBody(void* arg)

{
//hpr_guard<hpr_mutex> m_guard(g_mutex);
int nThreadnum=*(int*)arg;

//线程挂起等待
g_Semaphore.wait();

printf("creat thread :%d true\n", nThreadnum);
if(g_MsgQ.QueryTaskNum() != 0)
{
TASKEVENT* task = g_MsgQ.PopFirstTask();
if(task == NULL)
{
printf("get task error\n");
return ((void *)0);
}

int type = task->iMsgType;
int iPriority = task->iPriority;
std::vector<int> *vec = task->iDataVec;

printf("type:%d\n", type);

if(vec != NULL)
{
for(UINT32 j=0; j<vec->size(); ++j)
{
printf("data:%d\n", vec->at(j));
}
}
}
return ((void *)0);

}

void* __stdcall MyThread::producer(void* arg)

{
//线程类实例,暂时无用
MyThread*mThread = (MyThread*)arg;
printf("creat thread producer true\n");
TASKEVENT* task = new TASKEVENT;
std::vector<int> *vec = new std::vector<int>();
for(int i=0;i<10; ++i)
vec->push_back(i);
task->iMsgType = 1;
task->iPriority = 0;
task->iDataVec = vec;
g_MsgQ.PushTask(task);

//通知处理线程
g_Semaphore.post(1);

return ((void *)0);

}

int MyThread::creatProduct()

{
//创建生产者线程
HPR_HANDLE proHandle;

proHandle = MY_Thread_Create(MyThread::producer, this, 0);
if( proHandle == NULL)
{
SH_ERROR("creat thread proHandle failed!!\n");
return -1;
}
return 0;

}

int MyThread::creatConsumer()

{
HPR_HANDLE ret[THREAD_NUM_C];

for(int i=0; i<THREAD_NUM_C; ++i)
{
ret[i] = MY_Thread_Create(MyThread::threadBody, &i, 0);
if( ret[i] == NULL)
{
SH_ERROR("creat thread %d failed!!\n", i);
}
}
//g_Semaphore.post_1();
return 0;

}

main()

//**********************************//
MyThread myThread;
myThread.init();
//
myThread.creatProduct();
//
myThread.creatConsumer();
myThread.destory();

3、有时我们仅使用成员函数也可以达到该回调效果，例如：

#include <boost/bind.hpp>   

#include <boost/function.hpp>   

#include <iostream>   

  

// 函数对象 接受一个参数，返回值类型为 void  

typedef boost::function<void(const std::string &)> callback;   

  

class A   

{   

public:   

    void print(const std::string &msg)   

    {   

        std::cout << msg << std::endl;   

    }   

};   

  

class B   

{   

public:   

    //设置回调函数对象  

    void set_callback(callback cb)   

    {   

        m_cb = cb;   

    }   

  

    //调用回调函数对象  

    void do_callback()   

    {   

        m_cb("message");   

    }   

  

private:   

    callback m_cb;   

};   

  

void regular_function(const std::string &msg)   

{   

    std::cout << msg << std::endl;   

}   

  

int main()   

{   

    A a;   

    B b;   

      

    //成员函数用于回调  

    b.set_callback(boost::bind(&A::print, &a, _1));   

    b.do_callback();   

  

    // 普通函数指针同样适用  

    b.set_callback(regular_function);   

    b.do_callback();   

    return 0;  

}

4、利用多态机制,主要是子类实现继承父虚基类的纯虚函数，参数传递是只需传入基类指针即可。

//虚基类

class IMessage

{

public:
//纯虚函数
virtual void OnResponse(std::string& msg) = 0;

public:
//虚析构
virtual ~IMessage() {}

};

class CMessage: public IMessage

{

public:
CMessage(void);
~CMessage(void);

public:
//实现基类纯虚函数
void OnResponse(std::string& msg);

};

//*************************************//

void CMessage::OnResponse(std::string& msg)

{
printf("response is:%s\n", msg.c_str());

}

//***********************************//

bool notify(IMessage* pMsg)

{
std::string msg = "receive success";
pMsg->OnResponse(msg);
return true;

}

int _tmain(int argc, _TCHAR* argv[])

{

CMessage pMsg;
notify(&pMsg);

return 0;

}