C++实现回调函数的几种方式

目录
C++虚函数特性实现回调函数
C++结构体指针实现回调函数
C++11新特性td::tr1::function和std::tr1::bind实现回调函数
C++联合体union实现回调函数

通常认为通过函数指针在其他地方调用函数的过程称为回调，被调用的函数称为回调函数，函数指针通过传参方式传递。
在C++的实际应用中，有很多实现回调函数的方式，不一定要传递函数指针才能实现回调，只要实现了回调的功能，都叫回调函数。
回调函数是和调用者在同一线程，使用中要注意线程安全。
本章通过几个例子介绍C++实现回调函数的几种方式。
C++虚函数特性实现回调函数
这是最具C++特征的回调函数，基类定义纯虚函数，派生类实现虚函数，基类指针可以指向派生类，使用基类指针就可以调用派生类的虚函数，从而实现回调。
不足：利用虚函数特性实现回调函数的方式需要定义基类，通常是子类对父类的回调，当子类层级太多时需要逐级回调，实现起来比较繁琐。
代码实现：

#ifndef MANAGERINH_H
#define MANAGERINH_H

#include<string>
using namespace std;
class messageBase {//消息回调基类
public:
    messageBase() {};
    virtual ~messageBase() {};
    virtual void msgCallback(std::string msg)=0;
};

class employeeINH{//员工类
public:
    employeeINH(messageBase *msgBase){
        m_messageBase = msgBase;
    }
    void dowork(int count) {
        int sum = 0;
        for(int index=0;index<count;index++)
            sum += index*10;
        std::string msg = "total:" + to_string(sum);
        if(m_messageBase)
            m_messageBase->msgCallback(msg);//回调函数
    }
private:
    messageBase *m_messageBase;//消息回调基类对象指针，可以指向它的派生类，也就是 ManagerINH
};

class ManagerINH : public messageBase{//经理类，继承于消息回调基类
public:
    ManagerINH(){
        //创建子对象时，把父对象的指针传递过去
        pemployeeINH = new employeeINH(this);
    }

    virtual void msgCallback(std::string msg){//实现虚函数
        printf("result=%s\n",msg.c_str());
    }

    void sendwork(int num){
        pemployeeINH->dowork(num);
    }
private:
    employeeINH *pemployeeINH;
};
#endif // MANAGERINH_H

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
调用测试

ManagerINH mManagerINH;
mManagerINH.sendwork(10);
1
2
打印

result=total:450
1
C++结构体指针实现回调函数
把全局回调函数的指针、定义结构体对象的指针封装在一个结构体里，把这个结构体指针传递给子类，子类的子类等等，可以在程序的任何地方实现回调。
代码实现，managercon.h

#ifndef MANAGERCON_H
#define MANAGERCON_H

#include <string>
//回调结构体
struct ChwContext {
    //data      回调数据指针
    //nb_data   回调数据长度
    //user_this 指向当前结构体的指针
    void (*receiveQt)(char *data, int nb_data,void* user_this);
    void *user_callback;//回调函数所在对象的指针
};
#define safe_delete(a) {if( (a)) {delete (a); (a) = NULL;}}
#define safe_deleteA(a) {if( (a)) {delete[] (a); (a) = NULL;}}
#define safe_free(a) {if( (a)) {free((a)); (a) = NULL;}}

class EmployeeCON//员工类
{
public:
    EmployeeCON(ChwContext *pcontext){
        pChwContext = pcontext;
    }
    ChwContext *pChwContext;//由父对象传递过来的回调结构体指针

    void dowork(int count){
        int sum = 0;
        for(int index=0;index<count;index++)
            sum += index*10;

        std::string tmpstr = "total:" + std::to_string(sum);
        pChwContext->receiveQt((char*)tmpstr.c_str(),tmpstr.size(),pChwContext);//执行回调
    }
};

class ManagerCON//经理类
{
public:
    ManagerCON();
    ~ManagerCON();

    void sendwork(int count);
    void callback_receive(std::string msg);//回调函数
private:
    ChwContext *p_ChwContext;//回调结构体,在回调函数所在对象声明和定义,可传递给子类,子类的子类等
    EmployeeCON *pEmployeeCON;
};

#endif // MANAGERCON_H

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
managercon.cpp

#include "managercon.h"
//全局回调函数
void g_callback_receive(char *data, int nb_data ,void *obj) {
    if (obj == nullptr)
        return;
    ChwContext  *contx = (ChwContext*) obj;
    ManagerCON *mc = (ManagerCON*) contx->user_callback;
    std::string tmpstr(data,nb_data);
    mc->callback_receive(tmpstr);
}

ManagerCON::ManagerCON()
{
    p_ChwContext = new ChwContext;
    p_ChwContext->receiveQt = g_callback_receive;
    p_ChwContext->user_callback = this;

    pEmployeeCON = new EmployeeCON(p_ChwContext);
}

ManagerCON::~ManagerCON()
{
    safe_delete(pEmployeeCON);
    safe_delete(p_ChwContext);
}

void ManagerCON::sendwork(int count)
{
    pEmployeeCON->dowork(count);
}

void ManagerCON::callback_receive(std::string msg)
{
    printf("msg=%s\n",msg.c_str());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
调用测试

ManagerCON mManagerCON;
mManagerCON.sendwork(10);
1
2
打印

msg=total:450
1
C++11新特性td::tr1::function和std::tr1::bind实现回调函数
关于新特性参考：C++ std::tr1::function和std::tr1::bind模板类介绍，qt测试，这里不多说，直接上代码。
managerbind.h

#ifndef MANAGERBIND_H
#define MANAGERBIND_H

#include <iostream>
#include <tr1/functional>
#include <string>
class employeeBind{//员工类
public:
    employeeBind(){
    }
    void dowork(int count){
        int sum = 0;
        for(int index=0;index<count;index++)
            sum += index*10;
        std::string msg = "total:" + std::to_string(sum);
        if(Callback)
            Callback(msg);//回调函数
    }
    std::tr1::function<void(std::string)> Callback;
};

class ManagerBind//经理类
{
public:
    ManagerBind();

    employeeBind memployeeBind;
    void sendwork(int num);
    void callbackBD(std::string msg);
};

#endif // MANAGERBIND_H

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
managerbind.cpp

#include "managerbind.h"

ManagerBind::ManagerBind()
{
    memployeeBind.Callback = std::tr1::bind(&ManagerBind::callbackBD,this, std::tr1::placeholders::_1);
}

void ManagerBind::sendwork(int num){
    memployeeBind.dowork(num);
}

void ManagerBind::callbackBD(std::string msg)
{
    printf("msg=%s\n",msg.c_str());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
调用测试

ManagerBind mManagerBind;
mManagerBind.sendwork(10);
1
2
打印

msg=total:450
1
C++联合体union实现回调函数
union也叫联合体，在一个“联合体”内可以定义多种不同数据类型的变量，这些变量共享同一段内存，存储在内存中的起始地址相同，使用了覆盖计数，以达到节省空间的目的。union变量所占用的内存长度等于最长的成员变量的内存长度。
union的其中一个作用是实现简洁的线程回调函数。
managerunion.h

#ifndef MANAGERUNION_H
#define MANAGERUNION_H
#include <pthread.h>
#include <iostream>
#include <string>

class ManagerUnion;
//定义函数指针数据类型
typedef void* (ManagerUnion::*ThreadMeth)(void *);
typedef void* (*pThreadMethod)(void *);
class ManagerUnion
{
public:
    ManagerUnion();
    void startThread();
    void callbackUM(void *);
    int count;
    pthread_t m_threadID;
};
#endif // MANAGERUNION_H

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
managerunion.cpp

#include "managerunion.h"
ManagerUnion::ManagerUnion()
{
    count = 502;
    printf("ManagerUnion::ManagerUnion tid = %lu\n", pthread_self());
}

void ManagerUnion::startThread()
{
    union{//两个函数指针共享同一段内存
        pThreadMethod pFunc;
        void* (ManagerUnion::*ThreadMeth)(void *);
    }obj;

    obj.ThreadMeth = (ThreadMeth)&ManagerUnion::callbackUM;
    pthread_create(&m_threadID,0,obj.pFunc,this);//创建线程
}

//回调函数，也是线程处理函数，在子线程运行，调用的还是主类的函数
void ManagerUnion::callbackUM(void *)
{
    printf("ManagerUnion::callbackUM tid = %lu\n", pthread_self());

    printf("count=%d\n",count);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
调用测试

ManagerUnion mManagerUnion;
mManagerUnion.startThread();
1
2
打印

ManagerUnion::ManagerUnion tid = 139898503038848
ManagerUnion::callbackUM tid = 139898191017728
count=502
————————————————
版权声明：本文为优快云博主「夏天匆匆2过」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/weixin_40355471/article/details/128658573