C++回调函数理解

最新推荐文章于 2024-04-22 16:27:09 发布
最新推荐文章于 2024-04-22 16:27:09 发布
阅读量984 收藏 5
点赞数 2
分类专栏： # C++ # 设计模式 文章标签： c++ 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fb_941219/article/details/130895404
版权

C++回调函数理解

0.引言

看了一些介绍感觉太官方了，我的简单理解就是从模式设计思想出发，回调函数的目的就是为了将变化的模块抽离出来，延迟实现；固定的模块抽象出来设计好，“写死”。

请添加图片描述

1.回调函数的实现方式

在这里插入图片描述

2.普通函数以函数指针的形式进行实现

#include <iostream>

// ===========不变的模块，写死================
// 回调函数类型
typedef void (*CallbackFunction)(int);
// 带回调函数参数的函数
void PerformOperation(int value, CallbackFunction callback) {
    std::cout << "Performing operation with value: " << value << std::endl;
    // 执行某些操作...

    // 调用回调函数
    callback(value * 2);
}


// =========变化的模块，放到客户端进行实现========
// 回调函数的实现
void Callback(int result) {
    std::cout << "Callback received result: " << result << std::endl;
    // 执行回调操作...
}

int main() {
    int value = 5;

    // 调用带回调函数参数的函数
    PerformOperation(value, Callback);

    return 0;
}

3.类成员函数以静态函数进行实现

#include <iostream>

// ===========不变的模块，写死================
// 定义回调函数类型
typedef void (*CallbackFunction)(int);
// 带回调函数参数的函数
void PerformOperation(int value, CallbackFunction callback) {
    std::cout << "Performing operation with value: " << value << std::endl;
    // 执行某些操作...

    // 调用回调函数
    callback(value * 2);
}


// =========变化的模块，放到客户端进行实现========
// 回调类
class CallbackClass {
public:
	// 类的静态成员函数，当做全局函数使用
    static void Callback(int result) {
        std::cout << "Callback received result: " << result << std::endl;
        // 执行回调操作...
    }
};

int main() {
    int value = 5;
    // 创建回调类的对象
    CallbackClass callbackObj;
    // 将静态成员函数作为回调函数
    CallbackFunction callback = CallbackClass::Callback;
    // 调用带回调函数参数的函数
    PerformOperation(value, callback);
    return 0;
}

可以看出，以上两种方式没有什么本质的区别。

但这种实现有一个很明显的缺点：static 函数不能访问非static 成员变量或函数，会严重限制回调函数可以实现的功能。

4.类成员函数以非静态函数进行实现

  • 实现1
#include <iostream>
// ===========不变的模块，写死================
// 定义回调函数类型
typedef void (*CallbackFunction)(int);
// 带回调函数参数的函数
void PerformOperation(int value, CallbackFunction callback) {
    std::cout << "Performing operation with value: " << value << std::endl;
    // 执行某些操作...

    // 调用回调函数
    callback(value * 2);
}

// =========变化的模块，放到客户端进行实现========
// 回调类
class CallbackClass {
public:
    void Callback(int result) {
        std::cout << "Callback received result: " << result << std::endl;
        // 执行回调操作...
    }
};

int main() {
    int value = 5;

    // 创建回调类的对象
    CallbackClass callbackObj;
    // 将非静态成员函数作为回调函数
    CallbackFunction callback = [&](int result) {
        callbackObj.Callback(result);
    };
    // 调用带回调函数参数的函数
    PerformOperation(value, callback);

    return 0;
}
  • 实现2
#include <iostream>
// =========变化的模块，放到客户端进行实现========
class ProgramA {
 public:
  void FunA1() { printf("I'am ProgramA.FunA1() and be called..\n"); }

  void FunA2() { printf("I'am ProgramA.FunA2() and be called..\n"); }
};
// ===========不变的模块，写死================
class ProgramB {
 public:
  void FunB1(void (ProgramA::*callback)(), void *context) {
    printf("I'am ProgramB.FunB1() and be called..\n");
    ((ProgramA *)context->*callback)();
  }
};

int main(int argc, char **argv) {
  ProgramA PA;
  PA.FunA1();

  ProgramB PB;
  PB.FunB1(&ProgramA::FunA2, &PA);  // 此处都要加&
}

这种实现方式有很明显的缺点，不变的模块需要提前知道客户端的类型，显示不是很合理。

  • 实现3

这里还有一种方法可以避免这样的问题，可以把非static的回调函数 包装为另一个static函数，这种方式也是一种应用比较广的方法。

#include <iostream>

// =========变化的模块，放到客户端进行实现========
class ProgramA {
 public:
  void FunA1() { printf("I'am ProgramA.FunA1() and be called..\n"); }

  void FunA2() { printf("I'am ProgramA.FunA2() and be called..\n"); }

  static void FunA2Wrapper(void *context) {
    printf("I'am ProgramA.FunA2Wrapper() and be called..\n");
    ((ProgramA *)context)->FunA2();  // 此处调用的FunA2()是context的函数, 不是this->FunA2()
  }
};

// ===========不变的模块，写死================
class ProgramB {
 public:
  void FunB2(void (*callback)(void *), void *context) {
    printf("I'am ProgramB.FunB2() and be called..\n");
    callback(context);
  }
};

int main(int argc, char **argv) {
  ProgramA PA;
  PA.FunA1();

  ProgramB PB;
  PB.FunB2(ProgramA::FunA2Wrapper, &PA);
}

上面借助wrapper函数实现回调，虽然很灵活，但是还是不够优秀，比如：
- 1）多了一个不是太有实际用处的wrapper函数。
- 2）wrapper中还要对传入的指针进行强制转换。
- 3）FunB2调用时，不但要指定wrapper函数的地址，还要传入PA的地址。

5.std::funtion和std::bind的使用

#include <iostream>

#include <functional> // fucntion/bind
// =========变化的模块，放到客户端进行实现========
class ProgramA {
 public:
  void FunA1() { printf("I'am ProgramA.FunA1() and be called..\n"); }

  void FunA2() { printf("I'am ProgramA.FunA2() and be called..\n"); }

  static void FunA3() { printf("I'am ProgramA.FunA3() and be called..\n"); }
};

// ===========不变的模块，写死================
class ProgramB {
  typedef std::function<void ()> CallbackFun;
 public:
   void FunB1(CallbackFun callback) {
    printf("I'am ProgramB.FunB2() and be called..\n");
    callback();
  }
};

void normFun() { printf("I'am normFun() and be called..\n"); }

int main(int argc, char **argv) {
  ProgramA PA;
  PA.FunA1();

  printf("\n");
  ProgramB PB;
  PB.FunB1(normFun);
  printf("\n");
  PB.FunB1(ProgramA::FunA3);
  printf("\n");
  PB.FunB1(std::bind(&ProgramA::FunA2, &PA));
}

std::funtion支持直接传入函数地址，或者通过std::bind指定。

简而言之，std::funtion是定义函数类型(输入、输出)，std::bind是绑定特定的函数（具体的要调用的函数）。
​

6.c++回调的实现

#include <functional>
#include <iostream>
// ===========不变的模块，写死================
class MyTest{
public:
    MyTest() = default;
    void doCalc(){
        //干其他事，完了
        // 执行回调
        if(myCallBack!= nullptr){
            myCallBack(1,2);
        }
    }

    using callback_t = std::function<void(const int &a, const int &b)>;

    // 注册回调
    void setCallBackHandler(const callback_t &cb){
        myCallBack = cb;
    }

private:
    // 定义回调
    callback_t myCallBack;
};

// =========变化的模块，放到客户端进行实现========
// 回调函数
void handleCallBack(const int &a,const int &b){
    std::cout << "this is from callback handleCallBack"<<std::endl;
}

int main(){

    MyTest t;

    // 回调函数
    auto f= [](const int &a,const int &b){
        std::cout << "this is from callback f"<<std::endl;
    };
    // 注册回调
    // 写法一
    t.setCallBackHandler(f);

    // 写法二
    t.setCallBackHandler([&f](auto &&a, auto &&b) {
        f(std::forward<decltype(a)>(a), std::forward<decltype(b)>(b));
    });

    // 写法三
    t.setCallBackHandler([](auto &&a, auto &&b) {
        handleCallBack(std::forward<decltype(a)>(a), std::forward<decltype(b)>(b));
    });

    t.doCalc();
}

7.应用实例

  • 摘抄自高博的代码。

（1）写死的模块

  • io_utils.h
#include <fstream>
#include <functional>
#include <utility>

class TxtIO {
   public:
    TxtIO(const std::string &file_path) : fin(file_path) {}

    /// 定义回调函数
    using IMUProcessFuncType = std::function<void(const IMU &)>;
    using OdomProcessFuncType = std::function<void(const Odom &)>;
    using GNSSProcessFuncType = std::function<void(const GNSS &)>;

    TxtIO &SetIMUProcessFunc(IMUProcessFuncType imu_proc) {
        imu_proc_ = std::move(imu_proc);
        return *this;
    }

    TxtIO &SetOdomProcessFunc(OdomProcessFuncType odom_proc) {
        odom_proc_ = std::move(odom_proc);
        return *this;
    }

    TxtIO &SetGNSSProcessFunc(GNSSProcessFuncType gnss_proc) {
        gnss_proc_ = std::move(gnss_proc);
        return *this;
    }

    // 遍历文件内容，调用回调函数
    void Go();

   private:
    std::ifstream fin;
    IMUProcessFuncType imu_proc_;
    OdomProcessFuncType odom_proc_;
    GNSSProcessFuncType gnss_proc_;
};
  • io_utils.cc
#include "io_utils.h"
#include <glog/logging.h>

void TxtIO::Go() {
    if (!fin) {
        LOG(ERROR) << "未能找到文件";
        return;
    }

    while (!fin.eof()) {
        std::string line;
        std::getline(fin, line);
        if (line.empty()) {
            continue;
        }

        if (line[0] == '#') {
            // 以#开头的是注释
            continue;
        }

        // load data from line
        std::stringstream ss;
        ss << line;
        std::string data_type;
        ss >> data_type;

        if (data_type == "IMU" && imu_proc_) {
            double time, gx, gy, gz, ax, ay, az;
            ss >> time >> gx >> gy >> gz >> ax >> ay >> az;
            // imu_proc_(IMU(time, Vec3d(gx, gy, gz) * math::kDEG2RAD, Vec3d(ax, ay, az)));
            imu_proc_(IMU(time, Vec3d(gx, gy, gz), Vec3d(ax, ay, az)));
        } else if (data_type == "ODOM" && odom_proc_) {
            double time, wl, wr;
            ss >> time >> wl >> wr;
            odom_proc_(Odom(time, wl, wr));
        } else if (data_type == "GNSS" && gnss_proc_) {
            double time, lat, lon, alt, heading;
            bool heading_valid;
            ss >> time >> lat >> lon >> alt >> heading >> heading_valid;
            gnss_proc_(GNSS(time, 4, Vec3d(lat, lon, alt), heading, heading_valid));
        }
    }

    LOG(INFO) << "done.";
}

把读取文件的操作抽象出来写死，具体怎么处理留给回调函数（客户端）进行实现。

（2）变化的模块

    /// 记录结果
    auto save_result = [](std::ofstream& fout, double timestamp, const Sophus::SO3d& R, const Vec3d& v,
                          const Vec3d& p) {
        auto save_vec3 = [](std::ofstream& fout, const Vec3d& v) { fout << v[0] << " " << v[1] << " " << v[2] << " "; };
        auto save_quat = [](std::ofstream& fout, const Quatd& q) {
            fout << q.w() << " " << q.x() << " " << q.y() << " " << q.z() << " ";
        };

        fout << std::setprecision(18) << timestamp << " " << std::setprecision(9);
        save_vec3(fout, p);
        save_quat(fout, R.unit_quaternion());
        save_vec3(fout, v);
        fout << std::endl;
    };

    std::ofstream fout("./data/ch3/state.txt");
    io.SetIMUProcessFunc([&imu_integ, &save_result, &fout, &ui](const sad::IMU& imu) {
          imu_integ.AddIMU(imu);
          save_result(fout, imu.timestamp_, imu_integ.GetR(), imu_integ.GetV(), imu_integ.GetP());
          if (ui) {
              ui->UpdateNavState(imu_integ.GetNavState());
              usleep(1e2);
          }
      }).Go();

可以，还是很实用。

古路
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++中回调函数(CallBack)的用法分析
01-20
本文实例分析了C++中回调函数(CallBack)的用法。分享给大家供大家参考。具体分析如下： 如果试图直接使用C++的成员函数作为回调函数将发生错误，甚至编译就不能通过。 其错误是普通的C++成员函数都隐含了一个传递...
C++中的回调函数
MDtime的博客
08-14 124
std::function的实例可以对任何可以调用的目标实体进行存储、复制、和调用操作，这些目标实体包括普通函数、Lambda表达式、函数指针、以及其它函数对象等[1]。简而言之，std::funtion是定义函数类型(输入、输出)，std::bind是绑定特定的函数（具体的要调用的函数）。这种方法相对于上一种，ProgramB中没有ProgramA的任何信息了，是一种更独立的实现方式。std::bind()函数的意义就像它的函数名一样，是用来绑定函数调用的某些参数的[2]。还有更灵活、直接的方式。
python 函数修饰器 父类_Python函数嵌套、回调函数、闭包、装饰器和类
weixin_39731456的博客
01-28 227
markdown内容：Python函数嵌套、回调函数、闭包、装饰器和类一级标题：主要描述内容二级标题：各个内容三级标题：重要概念一、函数嵌套1.1、作用域和嵌套函数LEGB查找规则的 E， E 包括了任意外层函数局部作用域的形式。嵌套作用域有时也叫作静态嵌套作用域。1.2、变量名查找规则：LEGB 规则对于一条def语句：​ ---在默认情况下，变量名赋值会创建或者改变局部变量；​ ---...
【C++】C++回调函数基本用法（详细讲解）
测试开发自动化
08-09 5273
回调函数可以被简单地理解为：A函数作为参数传递给B函数，然后B函数在执行的某一时刻调用A函数。这里的A函数就是回调函数。
深蓝学院高翔《自动驾驶与机器人中的SLAM技术》学习记录1 Lambda 函数
Zcoasting的博客
11-06 391
深蓝学院高翔《自动驾驶与机器人中的SLAM技术》学习记录1 Lambda 函数相关记录
C++学习之回调函数
热门推荐
HAH--M的博客
07-28 1万+
参考文献 1. 什么是回调函数 回调函数就是通过函数指针调用函数。如果把函数的指针或者地址作为参数传递给另一个参数，当这个指针被用来调用其所指向的函数时，那么这就是一个回调的过程，这个被回调的函数就是回调函数。回调函数不是有该函数的实现方直接调用，而是在特定的事件或者条件发生时由另外的一方调用的，用于对该事件或者条件进行响应。回调函数就是在两个独立函数或者独立类通信的通道。 举个例子： 财务处是负责对公司财务状况和每个月的开销进行汇总 老板只会去看每个月的报表 那么在这个当中，老板不会去关心，财务整个汇总的
详解回调函数_c/c++
qq_41286360的博客
05-13 932
回调函数的理论基础是函数名是函数的入口地址，其入口地址可以赋值给一个函数指针变量，用此函数指针变量来调用函数。也可以让函数指针变量作为形参，用一个函数的入口地址（函数名）作为实参传入到这个函数指针变量中，完成了函数指针变量的赋值过程；函数的入口地址（函数名）指向的函数就是回调函数； 总而言之，回调函数的理论基础是函数指针；而函数指针的出现的原因是函数名称是函数的入口地址；函数作为一个编程语言的基本单元，必须理解透彻！更深层次的要清楚内存四驱模型和函数调用模型！这两个模型的深入理解是理解回调函数的终极目标！
跟我学c++高级篇——模板元编程之四Wrapper
fpcc的专栏
01-17 2173
对c++中的Wrapper进行分析说明，并举一些例子来测试
C/C++之回调函数
12-22
讨论下C/C++中的回调函数。 　在理解“回调函数”之前，首先讨论下函数指针的概念。 　函数指针 　（1）概念：指针是一个变量，是用来指向内存地址的。一个程序运行时，所有和运行相关的物件都是需要加载到内存中...
C++ 类中简单回调
09-23
首先明确一个概念，回调函数也是普通函数， 叫回调函数，是因为程序通过参数把该函数的函数指针传递给了其它函数，在那个函数里面调用这个函数指针就相当于调用这个函数，这样的过程就叫回调，而被调用的函数就叫回...
C++中回调函数及函数指针的实例详解
08-28
主要介绍了C++中回调函数及函数指针的实例详解的相关资料,希望通过本文能帮助到大家，让大家理解掌握这部分内容，需要的朋友可以参考下
详细讲解C++回调函数的文档！
12-17
详细讲解C++回调函数。对于很多初学者来说，往往觉得回调函数很神秘，很想知道回调函数的工作原理。本文将要解释什么是回调函数、它们有什么好处、为什么要使用它们等等问题，在开始之前，假设你已经熟知了函数指针。
C++ 中回调函数详解及简单实例
08-30
主要介绍了C++ 中回调函数详解及简单实例的相关资料,需要的朋友可以参考下
C++回调函数详解
07-31
我们经常在C++设计时通过使用回调函数可以使有些应用（如定时器事件回调处理、用回调函数记录某操作进度等）变得非常方便和符合逻辑，那么它的内在机制如何呢，怎么定义呢?它和其它函数（比如钩子函数）有何不同呢？ 使用回调函数实际上就是在调用某个函数（通常是API函数）时，将自己的一个函数（这个函数为回调函数）的地址作为参数传递给那个函数
怎么实现类的成员函数作为回调函数
12-26
如果试图直接使用C++的成员函数作为回调函数将发生错误，甚至编译就不能通过。其错误是普通的C++成员函数都隐含了一个传递函数作为参数，亦即“this”指针，C++通过传递this指针给其成员函数从而实现程序函数可以...
【C】 初识C语言
努力学习C/C++
04-21 757
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
C++ WebServer的细节理解
我的博客
04-22 589
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
C++——初识模板
最新发布
qq_74245477的博客
04-22 883
之前实现的数据结构，比如栈，我们为了便于修改存储的数据类型，通常使用typedef来重定义数据类型，但是这样有一个缺陷，会导致我们定义的栈存储的都是一种数据，如果同时需要两个栈，一个存储int，一个存储自定义类型，那么typedef就不管用了。比如：当用int类型使用函数模板时，编译器通过对实参类型的推演，将T确定为int类型，然后产生一份专门处理int类型的代码，对于字符类型也是如此。概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型的版本。
C语言：贪吃蛇游戏（万字解读超详细）
2301_80655639的博客
04-20 1042
贪吃蛇这个游戏应该我们小时候都玩过吧我相信能够点进这个博客的应该都很熟悉这个游戏了如果对这个游戏不熟悉的可以网上查查怎么玩，这样才能对这个游戏有个清晰的认知该篇博客需要拥有C语言基础（对指针熟悉、会链表的使用）下面我们需要先学习一些C语言之外的东西认真坚持看完，我相信你一定能完成这个接近500行的C语言贪吃蛇项目该类型内部封装了两个成员，一个x，一个y，代表坐标我们可以将我们的控制台理解为一个平面坐标图横向正方向是x轴正方向，竖向负方向是y轴正方向。
回调函数 c++代码实例
03-14
回调函数是一种常见的编程技术，它允许我们将一个函数作为参数传递给另一个函数，并在需要的时候调用它。在C++中，回调函数通常通过函数指针或函数对象来实现...希望以上代码示例能够帮助你理解回调函数的概念和用法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值