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

最新推荐文章于 2024-07-10 10:08:51 发布
最新推荐文章于 2024-07-10 10:08:51 发布
阅读量1w 收藏 86
点赞数 23
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuejisuo1948/article/details/113280498
版权

目录

一、使用函数指针

二、新建类继承接口类并实现虚方法

三、直接继承接口类并实现虚方法

四、使用std::future和std::async

考虑两个类之间的异步场景：客户端调用类A处理某个任务，A需要委托B进行一些处理并返回结果；并且都是异步进行，即函数迅速返回之后在后台进行计算，完毕后通知调用者。

一、使用函数指针

类B需要有SetCallBack接口来接收函数指针，此处我们用std::function来实现。

B在进行ProcessAsync任务时另起一个线程并去进行较长时间的后台计算(此处用std::this_thread::sleep_for来模拟长时间计算)，计算完成后通过刚才设置进来的函数指针来通知调用者。

#include <iostream>
#include <functional>
#include <thread>
 
class B
{
public:
    void SetCallBack(const std::function<void(double)> &cb) {
        m_callback = cb;
    }
    void ProcessAsync() {
        printf("class B, create thread to compute and return immediately\n");
        m_th = std::thread(&B::ProcessReal, this);
    }
    ~B() {
        printf("begin to destroy B\n");
        if (m_th.joinable()) {
            m_th.join();  //析构时保证子线程join进来
        }
        printf("~B\n");
    }
    
private:
    void ProcessReal() {
        printf("class B, Process for a long time...\n");
        std::this_thread::sleep_for(std::chrono::seconds(3));
        if (m_callback) {
            printf("callback\n");
            m_callback(3.72);  //该函数指针可能是个野指针
        }
    }
    std::function<void(double)> m_callback;
    std::thread m_th;
};

类A在向类B设置回调时既可以用lambda表达式也可以用std::bind，建议用lambda。 A收到回调时打印计算结果result。

#include <iostream>
#include <memory>
#include <functional>
#include <mutex>
#include "B.h"

class A
{
public:
    void DoTask() {
        printf("class A, DoTask\n");
        m_b = std::make_unique<B>();
        m_b->SetCallBack([this](double res) {return OnProcessDone(res);}); //用lambda
        //m_b->SetCallBack(std::bind(&A::OnProcessDone, this, std::placeholders::_1)); //用bind
        m_b->ProcessAsync();
    }
    ~A() {
        printf("~A\n");
    }
private:
    void OnProcessDone(double result) {
        std::unique_lock<std::mutex> lock(m_mtx);
        printf("OnProcessDone, result = %f\n", result);
        m_res = result;
    }
    std::unique_ptr<B> m_b{nullptr};
    double m_res;
    std::mutex m_mtx;
};

主函数就不多说了

#include "A.h"
 
int main() {
    A a;
    a.DoTask();
    return 0;
}

这种方式有个问题是，B在回调A的成员函数时，可能A的实例已经被销毁，导致访问的成员变量已经不存在。解决方法是由A来管理B的生命周期，且在B析构时需要保证所有子线程都已经join进来。

 

二、新建类继承接口类并实现虚方法

B提供一个接口类Listener，接口类中有一个纯虚方法OnProcessDone；

#include <iostream>
#include <functional>
#include <thread>
#include <memory>

class B
{
public:
    class Listener {
    public:
        virtual void OnProcessDone(double result) = 0;
    };
    void SetCallBack(const std::shared_ptr<Listener> &cb) {
        m_callback = cb;
    }
    void ProcessAsync() {
        printf("class B, create thread to compute and return immediately\n");
        m_th = std::thread(&B::ProcessReal, this);
    }
    ~B() {
        if (m_th.joinable()) {
            m_th.join();
        }
        printf("~B\n");
    }
    
private:
    void ProcessReal() {
        printf("class B, Process for a long time...\n");
        std::this_thread::sleep_for(std::chrono::seconds(3));
        if (m_callback) {
            printf("callback\n");
            m_callback->OnProcessDone(3.72);
        }
    }
    std::shared_ptr<Listener> m_callback;
    std::thread m_th;
};

而在A中可以新声明一个内部类MyListener来继承B::Listener，并实现这个虚方法。

A::MyListener声明成内部类的好处是：内部类默认是外部类的友元，则A::MyListener就可以访问类A的私有成员，若回调需要访问私有成员时这种写法十分方便。

A中的MyListener需要存储A的指针用于访问A的成员，可以用weak_ptr或裸指针，但不要用shared_ptr，否则会出现循环引用、导致内存泄漏。（A保存了B的sharedptr，B保存了MyListener的sharedptr，MyListener又保存了A的sharedptr，谁也不会被释放）。

本例使用了weak_ptr，首先检查它是否过期（expired），然后再进行对应的操作，避免操作指向A的野指针。

#include <iostream>
#include <memory>
#include <functional>
#include <mutex>
#include "B.h"

class A : public std::enable_shared_from_this<A>
{
public:
    void DoTask() {
        printf("class A, DoTask\n");
        m_b = std::make_shared<B>();
        m_b->SetCallBack(std::make_shared<MyListener>(weak_from_this()));
        m_b->ProcessAsync();
    }
    ~A() {
        printf("~A\n");
    }
private:
    class MyListener : public B::Listener {
    public:
        MyListener(std::weak_ptr<A> a) : m_a(a) {}
        void OnProcessDone(double result) override {
            printf("OnProcessDone, result = %f\n", result);
            if (!m_a.expired()) {
                std::shared_ptr<A> a = m_a.lock();
                std::unique_lock<std::mutex> lock(a->m_mtx);
                a->m_res = result; //内部类可以访问外部类的私有成员
            }
        }
    private:
        std::weak_ptr<A> m_a; //弱引用
    };
    
    std::shared_ptr<B> m_b{nullptr};
    double m_res;
    std::mutex m_mtx;
};

由于使用了std::enable_shared_from_this，所以主函数在生成A时也要改成智能指针：

#include "A.h"

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    a->DoTask();
    return 0;
}

三、直接继承接口类并实现虚方法

由于我们的类A对类B是强引用，为了避免把A设置给B产生循环引用，需要把B对listener的引用设置为弱引用：

#include <iostream>
#include <functional>
#include <thread>
#include <memory>

class B
{
public:
    class Listener {
    public:
        virtual void OnProcessDone(double result) = 0;
    };
    void SetCallBack(const std::weak_ptr<Listener> &cb) {
        m_callback = cb;
    }
    void ProcessAsync() {
        printf("class B, create thread to compute and return immediately\n");
        m_th = std::thread(&B::ProcessReal, this);
    }
    ~B() {
        if (m_th.joinable()) {
            m_th.join();
        }
        printf("~B\n");
    }
    
private:
    void ProcessReal() {
        printf("class B, Process for a long time...\n");
        std::this_thread::sleep_for(std::chrono::seconds(3));
        if (m_callback.expired()) {
            printf("callback expired\n");
            return;
        }
        printf("callback\n");
        m_callback.lock()->OnProcessDone(3.72);
    }
    std::weak_ptr<Listener> m_callback; //弱引用
    std::thread m_th;
};

 

#include <iostream>
#include <memory>
#include <functional>
#include <mutex>
#include "B.h"

class A : public B::Listener, public std::enable_shared_from_this<A>
{
public:
    void DoTask() {
        printf("class A, DoTask\n");
        m_b = std::make_unique<B>();
        m_b->SetCallBack(weak_from_this());
        m_b->ProcessAsync();
    }
    ~A() {
        printf("~A\n");
    }
private:
    void OnProcessDone(double result) override {
        printf("OnProcessDone, result = %f\n", result);
        std::unique_lock<std::mutex> lock(m_mtx);
        m_res = result;
    }
    std::unique_ptr<B> m_b{nullptr};
    double m_res;
    std::mutex m_mtx;
};

 方法二和方法三的区别是判断引用失效的位置不同，一个是在新建的类中，一个是在被委托的类中。

 

四、使用std::future和std::async

这种方式已经没有回调了，做法是在类A中启动一个std::async，将B的同步处理函数变成异步的，这样就不需要向B设置回调了，B的实现会非常简单。 A中在需要计算结果时调用future的.get()就可以取到结果。

#include <iostream>
#include <thread>

class B
{
public:
    double ProcessSync() {
        printf("class B, Process for a long time...\n");
        std::this_thread::sleep_for(std::chrono::seconds(3));
        return 3.72;
    }
};

 要注意std::future是不可拷贝的，所以把future传到另一个线程时要move过去。

#include <iostream>
#include <memory>
#include <functional>
#include <future>
#include "B.h"

class A
{
public:
    void DoTask() {
        printf("class A, DoTask\n");
        m_b = std::make_shared<B>();
        std::future<double> fut = std::async(std::bind(&B::ProcessSync, m_b));
        std::thread th(&A::WaitForProcessDone, this, std::move(fut));
        th.detach();
    }
private:
    void WaitForProcessDone(std::future<double> &&fut) {
        double result = fut.get();
        printf("ProcessDone, result = %f\n", result);
        m_res = result;
    }
    std::shared_ptr<B> m_b{nullptr};
    double m_res;
};

 

想深入进阶了解的可以看这篇，chromium实现的高效回调  https://cloud.tencent.com/developer/article/1519851

_沥川往事
关注
  • 23
    点赞
  • 踩
  • 86
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
浅析 C++ 回调的几种方式
半雨微凉
07-11 9661
简单说明： 简单来说，就是B在完成某件事的时候，自动执行A的相关操作~ A、B可以是普通函数，也可以是类 大致可以分为三种方式的回调： 1、普通函数的方式 函数定义： void print1() { cout << "1" << endl; } void print2() { cout << "2" << endl; } ...
C++回调的几种方式
Code_Hu的博客
11-24 1004
自己平时常用到的C++回调方式主要为两类 通过设置函数指针的方式 通过集成接口的方式（Sink下沉） 一. 设置接口sink的方式 一般都是由一个消息接口类，作为回调，需要处理返回回调的信息的类，只需要继承接口类，并实现对应的方法即可。初始化时，只需要将子类设置下去，待任务完成时，就可以实现回调。 简单的模仿一下文件传输，ITaskCallback为消息回调接口，需要该消息回调的类，只需要继承...
JNA 回调 范例 C++异步回调实现
12-19
这几天搞搞JNA，主要是组内小弟靠不住。 找了下资料，居然没有回调函数的样例，郁闷的我不行，于是就自己折腾一晚上，自己实现一个。 C++部分使用ACE实现了一个线程，线程中调用Java部分的回调函数。 C++使用vc8开发，代码跨平台，不过偷懒，没写makefile, 其中使用了ACE这个库。 Java部分，使用eclipse。jdk1.5版本。
C++进阶——回调函数详解
最新发布
qq_74811378的博客
07-10 397
总之，所谓回调函数就是把函数当作参数使用。目的是使程序更加普适（正如活字印刷，把可能会“变”的字一个个分离开来，这样就可以任意组合，重复利用）。一般情况下，一个人的小规模程序用不着这种普适性，除非你想把它做成工具箱（比如游戏引擎），供他人使用。
【C++】C++回调函数基本用法（详细讲解）
测试开发自动化
08-09 8828
回调函数可以被简单地理解为：A函数作为参数传递给B函数，然后B函数在执行的某一时刻调用A函数。这里的A函数就是回调函数。
C++学习之回调函数
HAH--M的博客
07-28 1万+
参考文献 1. 什么是回调函数 回调函数就是通过函数指针调用函数。如果把函数的指针或者地址作为参数传递给另一个参数，当这个指针被用来调用其所指向的函数时，那么这就是一个回调的过程，这个被回调的函数就是回调函数。回调函数不是有该函数的实现方直接调用，而是在特定的事件或者条件发生时由另外的一方调用的，用于对该事件或者条件进行响应。回调函数就是在两个独立函数或者独立类通信的通道。 举个例子： 财务处是负责对公司财务状况和每个月的开销进行汇总 老板只会去看每个月的报表 那么在这个当中，老板不会去关心，财务整个汇总的
C++回调函数详解
热门推荐
qq_45311905的博客
05-10 2万+
1、什么是回调函数 2、为什么需要回调函数 3、什么函数可以作为回调函数
C++实现回调函数的几种方式
weixin_40355471的博客
01-14 4880
C++虚函数特性实现回调函数，C++结构体指针实现回调函数， C++11新特性td::tr1::function和std::tr1::bind实现回调函数，C++联合体union实现回调函数，线程回调函数。
c++回调之利用sink示例
09-04
在本示例中，我们将探讨如何使用"Sink"（接收器）概念来实现回调，这是一种利用C++面向对象特性的方法，相比传统的函数指针回调，它提供了更好的封装性和灵活性。 首先，我们来看一下`Sink`的核心概念。在C++中，`...
c++ dll 消息回调
03-13
在“c++ dll 消息回调”这个场景中，我们需要理解如何从DLL调用主程序（宿主程序）的函数，并在处理完成之后，通过消息回调的方式将结果返回给DLL。这通常涉及到以下几个关键知识点： 1. **DLL导出函数**： DLL中...
怎么实现类的成员函数作为回调函数
09-04
然而，有几种方法可以实现类的成员函数作为回调函数。 **1. 使用友元函数（Friend Function）** 友元函数不是类的成员，但可以访问类的私有和保护成员。当需要一个非成员函数访问类的私有数据成员时，可以声明这个...
C++基础入门教程（九）：函数指针之回调
09-04
在C++编程中，函数指针是一个非常重要的概念，它允许我们将函数的地址作为一个值进行传递，从而在程序的不同部分之间实现回调功能。回调是一种设计模式，它允许一个函数或方法在执行过程中调用由其参数提供的其他...
C++中模块（Dll）对外暴露接口的几种方式
12-22
　缺点是这种方式是面向过程的，外部如果要支持多实例等不是很方便，另外它要求的回调函数(callback)只能是普通C函数，C++中我们通常用类静态成员函数，很不方便。 　当然，我们通过封装其实也可以让这种方式支持...
c++回调函数详解及实现(lambda)
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
08-20 7306
回调函数就是一个被作为参数传递的函数。在C语言中，回调函数只能使用函数指针实现，在C++语言中还可以使用仿函数或匿名函数。回调函数的使用可以大大提升编程的效率，这使得它在现代编程中被非常多地使用。
C++回调函数
mayue_web的博客
04-07 4318
如果你把函数的指针（地址）作为参数传递给另一个函数，回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。p指向Max函数之后，然后用p调用Max函数，返回两个数中的最大值。特别注意的是，因为函数名本身就可以表示该函数地址（指针），因此在获取函数指针时，可以直接用函数名，也可以取函数的地址。前面函数指针的方式作为回调函数的一种方式，可以同时用于C和C++，下面介绍另外的一些方式，因为C++引入了对象的概念，可以使用类的成员和静态函数作为回调函数。
c++ 回调实现的几种方式
u013031697的博客
11-24 1525
c++ 回调实现的几种方式
C++-回调函数
m0_52902391的博客
09-17 4001
1. 什么是回调函数？ 回调函数，光听名字就比普通函数要高大上一些，那到底什么是回调函数呢？恕我读得书少，没有在那本书上看到关于回调函数的定义。我在百度上搜了一下，发现众说纷纭，有很大一部分都是使用类似这么一个场景来说明：A君去B君店里买东西，恰好缺货，A君留下号码给B君，有货时通知A君。感觉这个让人更容易想到的是异步操作，而不是回调。另外还有两句英文让我印象深刻：1) If you call me, I will call you back; 2) Don't call me, I will call
【C/C++】回调函数
东西山海关
06-09 1951
回调函数是一种在程序运行期间，它通常用于。在回调函数的使用中，当某些事件发生时，系统会调用预先注册好的回调函数，将事件相关的数据传递给回调函数，由回调函数进行处理。这种回调函数的机制常用于异步通信、网络编程、GUI 前端等场景中，常见的回调函数包括事件处理函数、信号处理函数、消息处理函数等。回调函数通常使用函数指针来进行实现，首先定义一个函数指针类型，然后将回调函数的地址赋值给函数指针，最后在需要注册回调函数的地方将函数指针作为参数传入即可。在回调函数中，，而。
C/c++有几种实现函数回调的方式
06-06
在 C/C++ 中，实现函数回调的方式有以下几种： 1. 函数指针：将一个函数的地址作为参数传递给另一个函数，便可以在后者中调用前者，从而实现回调。 2. 函数对象：将一个可调用对象（如函数对象、Lambda 表达式等）作为参数传递给另一个函数，便可以在后者中调用前者，从而实现回调。 3. 函数模板：在模板参数中使用函数指针或函数对象类型，然后在函数体中调用该函数指针或函数对象，从而实现回调。 4. 回调接口类：定义一个接口类，其中包含一个或多个纯虚函数，然后在另一个类中将该接口类作为参数传递给函数，在函数体中调用该接口类的纯虚函数，从而实现回调。 总之，C/C++ 中实现函数回调的方式有很多种，选择何种方式取决于具体的需求和场景。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值