C/C++ 回调函数 callback 异步编程

一、C语言的回调函数

1.小试牛刀 

#include <iostream>
using namespace std;
#include <memory>
#include <stdlib.h>int add(int a, int b) {return a + b;
}void test01() {// 函数指针可以指向任何类型的函数，只要函数的参数列表和返回值类型匹配即可int (*pFunc)(int,int) = add;// 函数指针可以像普通函数一样被调用，通过函数指针变量名加上括号的方式int result = (*pFunc)(1,2);cout << result << endl; // 输出 3
}// typedef 返回类型(*新的函数名)(参数列表)
typedef int (*INT_func)(int,int);
void test02() {INT_func pFunc = add;int result = pFunc(2,3);cout << result << endl; // 输出 5
}// 回调函数,它允许一个函数作为参数传递给另一个函数
// 这种特性使得我们可以将一些特定的任务委托给其他函数来完成// 定义一个函数指针类型
typedef void(*Callback)(int);
// 定义一个函数，该函数接受一个回调函数作为参数
void doSomething(Callback callback) {cout<<"Doing something..."<<endl;// 调用回调函数int data = 1024;callback(data);
}// 定义一个回调函数
void printMyData(int data) {cout<<"My data is: "<<data<<endl;
}int main() {test01();test02();// 将回调函数传递给doSomething函数/*doSomething函数接受一个Callback类型的参数,这是一个指向函数的指针.doSomethings函数调用这个回调函数,并且将一个整型变量作为参数传递给它printMyData在此是一个简单的回调函数,它接受一个整型变量作为参数并且把它打印出来*/doSomething(printMyData);return 0;
}
  • 打印结果：
PS D:\Work\c++> ./bin/app     
3
5
Doing something...
My data is: 1024
PS D:\Work\c++>

2.动态函数指针 

在学习这个知识点的时候，我遇到的坑，非常感谢这位大佬给我指点迷津：

动态函数指针free报错_编程语言-CSDN问答icon-default.png?t=N7T8https://ask.csdn.net/questions/8061857?spm=1001.2014.3001.5505

  • micthis大佬写的代码
#include <iostream>
using namespace std;
#include <memory>
#include <stdlib.h>
int add(int a, int b) {return a + b;
}
/*动态函数指针是指在运行时根据需要动态分配和修改的函数指针它可以在程序运行时根据需要指向不同的函数,从而实现更加灵活和动态的函数调用在c++中,可以使用动态内存分配函数(如malloc或new)来创建动态函数指针
*/
int test01() {// 创建一个指向函数的指针int(**pFunc)(int, int);// 使用malloc动态分配内存int size = sizeof(int(*)(int, int));pFunc = (int(**)(int, int))malloc(size);// 将函数指针指向 add函数*pFunc = add;// 调用函数int result = (*pFunc)(2, 3);cout << result << endl; // 输出 5// 释放内存free(pFunc);return 0;
}
int main() {test01();return 0;
}

打印结果： 

PS D:\Work\c++> ./bin/app
5
PS D:\Work\c++>

3.异步编程

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>// A的实现,一般会隐藏
typedef void (*CallbackPtr)(int);// 函数指针定义typedef struct dataCB{int data;CallbackPtr callback;
}dataCB;// 创建实例
dataCB dataCBInstance = {0, NULL};void* callback_thread(void* arg) { // 此处用的是一个线程// 循环改变p->a的值为 0 1 2 3 4 5 6 7 8 9,每个3s改变一次dataCB* p = (dataCB*)arg;while (1) {sleep(3);// 延时3s执行callback函数p->callback(p->data);// 函数指针执行函数,这个函数来自于应用层Bp->data = (p->data + 1) % 10;}
}void startup_app_A() {// 创建线程pthread_t tid;pthread_create(&tid, NULL, callback_thread, (void*)&dataCBInstance);   
}// 给B的接口,接收注册函数
extern void SetCallBackFun(CallbackPtr cb) {printf("SetCallBackFun print! \n");dataCBInstance.callback = cb;
}// //-----------------------应用者B-------------------------------
void recieve(int data)       // 应用者增加的函数，此函数会在A中被执行
{//do somethingprintf("B得到A的数据 = %d\n",data);
}int main(void) {// 启动Astartup_app_A();SetCallBackFun(recieve);// 主函数while (1) {// std::cout << "main function" << std::endl;printf("main function\n");sleep(2);}return 0;
}
PS D:\Work\c++> ./bin/app
SetCallBackFun print!
main function
main function
B得到A的数据 = 0
main function
B得到A的数据 = 1
main function
main function
B得到A的数据 = 2
main function
B得到A的数据 = 3
main function
main function
B得到A的数据 = 4
main function
B得到A的数据 = 5
main function
main function
B得到A的数据 = 6
main function
B得到A的数据 = 7
main function
main function
B得到A的数据 = 8
main function
B得到A的数据 = 9
main function
main function
B得到A的数据 = 0
main function
B得到A的数据 = 1
main function
main function
B得到A的数据 = 2
main function
B得到A的数据 = 3
main function
main function
B得到A的数据 = 4
main function
B得到A的数据 = 5
main function
main function
B得到A的数据 = 6
main function
B得到A的数据 = 7
main function
main function
B得到A的数据 = 8
main function
B得到A的数据 = 9
main function
main function
B得到A的数据 = 0
main function

参考文章：C/C++面向对象（OOP）编程-回调函数详解（回调函数、C/C++异步回调、函数指针）-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_47324800/article/details/135315345

二、C++回调函数

1.动态函数指针

#include <iostream>
using namespace std;
#include <memory>
#include <stdlib.h>
int add(int a, int b) {return a + b;
}
/*动态函数指针是指在运行时根据需要动态分配和修改的函数指针它可以在程序运行时根据需要指向不同的函数,从而实现更加灵活和动态的函数调用在c++中,可以使用动态内存分配函数(如malloc或new)来创建动态函数指针
*/
typedef int(*handleFunc)(int,int);
int test01() {// 创建一个指向函数的指针int(**pFunc)(int, int);pFunc = new handleFunc;// 将函数指针指向 add函数*pFunc = add;// 调用函数int result = (*pFunc)(2, 3);cout << result << endl; // 输出 5// 释放内存delete pFunc;pFunc = nullptr;return 0;
}
int main() {test01();return 0;
}

  2.简单回调

#include <iostream>
#include <functional>// 定义一个回调函数类型
typedef std::function<void(int)> Callback;// 定义一个接受回调函数的函数
void process(int value,Callback callback) {std::cout<<"传入处理值: "<<value<<std::endl;callback(value); // 调用回调函数
}// 定义一个回调函数
int add(int value) {value += 10;std::cout<<"传出结果值: "<<value<<std::endl;return value;
}int main() {int value = 42;process(value,add); // 传递回调函数给process函数return 0;
}

执行结果：

PS D:\Work\c++> ./bin/app
传入处理值: 42
传出结果值: 52
PS D:\Work\c++>

 3.使用包装器function 

参考文章：C++之可调用对象、bind绑定器和function包装器_完整实现bind和function代码c++-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/weixin_65743593/article/details/128963676

 (1) 可调用对象

// 可调用对象
/*在C++中，可以像函数一样的调用的有：普通函数，类的静态成员函数、仿函数、lambda函数，类的非静态成员函数、可被转换为函数的类的对象，统称可调用对象或函数对象可调用对象有类型，可以用指针存储它们的地址，可以被引用（类的成员函数除外）
*/#include <iostream>
using namespace std;
class Object {
public:// 仿函数void operator()(int age, string name) {cout << "年龄：" << age << ",姓名：" << name << endl;}// 类的非静态成员函数void show(int age, string name) {cout << "年龄：" << age << "，姓名：" << name << endl;}
};// 仿函数
void test01() {Object obj;obj(20, "呵呵哒");Object& objRef = obj; // 引用函数objRef(18, "小比尔");
}// lambda函数
void test02() {auto func = [](int age, string name) {cout << "年龄：" << age << ",姓名：" << name << endl;};func(20, "heheda");auto& funcRef = func;// 引用lambda对象funcRef(23, "小比尔");
}// 类的非静态成员函数有地址，但是只能通过类的对象才能调用它，
// C++对它做了特别处理，类的非静态成员函数只有指针类型，
// 没有引用类型，不能引用
void test03() {Object obj;obj.show(30, "智慧老人");void(Object:: *pobj)(int, string) = &Object::show; // 定义类的成员函数的指针(obj.*pobj)(20, "呵呵哒");using PFun = void(Object::*)(int, string);PFun pShow = &Object::show;(obj.*pShow)(78, "圣诞老人");
}int main() {test03();return 0;
}

（2）C++之可调用对象，bind绑定器和function包装器

// 包装器function
// 包含头文件：#include <functional>
// std::function<返回值类型(参数类型列表)> diy_name = 可调用对象;#include <iostream>
#include <functional>
#include <string>
using namespace std;
enum OP {ADD,MUL,SUB
};int add(int a, int b) {return a + b;
}using handleFunc = function<int(int, int)>;
class Object {
public:int add(int a, int b) {return a + b;}static int sub(int a, int b) {return a - b;}static int mul(int a, int b) {return a * b;}// 仿函数int operator()(int a, int b, handleFunc cb, OP op) {switch (op) {case ADD:cout << "("<< a << "+" << b << ") = ";break;case MUL:cout << "(" << a << "*" << b << ") = ";break;case SUB:cout << "(" << a << "-" << b << ") = ";break;}cout << cb(a, b) << endl;return cb(a, b);}
};void test01() {Object obj;function<int(int, int)> func = add;cout << func(1, 2) << endl;
}void test02() {Object obj;handleFunc addCB = std::bind(&Object::add, &obj, std::placeholders::_1, std::placeholders::_2);cout << "addCB(1, 2): " << addCB(1, 2) << endl;handleFunc subCB = Object::sub;cout << "subCB(9, 3): " << subCB(9, 3) << endl;subCB = obj.mul;cout << "subCB(10, 6): " << subCB(10, 6) << endl;handleFunc mulCB = Object::mul;cout << "mulCB(3, 3): " << subCB(3, 3) << endl;subCB = obj.mul;cout << "mulCB(2, 6): " << subCB(2, 6) << endl;function<int(int, int, handleFunc, OP)> operCB = obj;operCB(2, 3, add, ADD);operCB(4, 1, obj.sub, SUB);operCB(2, 9, obj.mul, MUL);
}int main() {//test01();test02();return 0;
}

#include <iostream>
#include <functional>
using namespace std;
using handleFunc = function<void()>;
class Object {
public:// 构造函数参数是一个包装器对象Object(const handleFunc& f) :m_callback(f) {}void notify() {m_callback();// 调用通过构造函数得到的函数指针}
private:handleFunc m_callback;
};class Subject{
public:void operator()() { cout << "heheda" << endl; }
};int main() {Subject s;Object obj(s);obj.notify();return 0;
}

#include <iostream>
#include <functional>
using namespace std;
class Person {
public:// 仿函数void operator()(int age, string name) {cout << "age: " << age << ",name: " << name << endl;}void show(int age, string name) {cout << "age: " << age << ",name: " << name << endl;}
};void test01() {Person person;// 仿函数function<void(int, string)> opFunc = bind(Person(), placeholders::_1, placeholders::_2);opFunc(20,"heheda");// 类成员函数需要绑定该类的this指针 Person p1;function<void(Person&, int, string)> showFunc = bind(&Person::show,placeholders::_1, placeholders::_2, placeholders::_3);showFunc(p1, 17, "Tom");// 为了统一，将对象提前绑定function<void(int, string)> showFunc2 =bind(&Person::show, p1, placeholders::_1, placeholders::_2);showFunc2(8, "Jerry");
}int main() {test01();
}

#include <iostream>
#include <functional>
#include <thread>
#include <unistd.h>
using namespace std;// A的实现,一般会隐藏
using CallbackPtr = std::function<void(int)>;typedef struct dataCB{int data;CallbackPtr callback;
}dataCB;// 创建实例
dataCB dataCBInstance = {0, NULL};void* callback_thread(void* arg) { // 此处用的是一个线程// 循环改变p->a的值为 0 1 2 3 4 5 6 7 8 9,每个3s改变一次dataCB* p = (dataCB*)arg;while (1) {sleep(3);// 延时3s执行callback函数p->callback(p->data);// 函数指针执行函数,这个函数来自于应用层Bp->data = (p->data + 1) % 10;}
}void startup_app_A() {// 创建线程std::thread(callback_thread, (void*)&dataCBInstance).detach(); // .detach()分离线程
}// 给B的接口,接收注册函数
extern void SetCallBackFun(CallbackPtr cb) {printf("SetCallBackFun print! \n");dataCBInstance.callback = cb;
}// //-----------------------应用者B-------------------------------
void recieve(int data)       // 应用者增加的函数，此函数会在A中被执行
{//do somethingprintf("B得到A的数据 = %d\n",data);
}int main(void) {// 启动Astartup_app_A();SetCallBackFun(recieve);// 主函数while (1) {printf("main function\n");sleep(2);}return 0;
}

（3）异步编程

#include <iostream>
#include <functional>
#include <thread>
#include <unistd.h>
using namespace std;// A的实现,一般会隐藏
using CallbackPtr = std::function<void(int)>;typedef struct dataCB{int data;CallbackPtr callback;
}dataCB;// 创建实例
dataCB dataCBInstance = {0, NULL};void* callback_thread(void* arg) { // 此处用的是一个线程// 循环改变p->a的值为 0 1 2 3 4 5 6 7 8 9,每个3s改变一次dataCB* p = (dataCB*)arg;while (1) {sleep(3);// 延时3s执行callback函数p->callback(p->data);// 函数指针执行函数,这个函数来自于应用层Bp->data = (p->data + 1) % 10;}
}void startup_app_A() {// 创建线程std::thread(callback_thread, (void*)&dataCBInstance).detach(); // .detach()分离线程
}// 给B的接口,接收注册函数
extern void SetCallBackFun(CallbackPtr cb) {printf("SetCallBackFun print! \n");dataCBInstance.callback = cb;
}// //-----------------------应用者B-------------------------------
void recieve(int data)       // 应用者增加的函数，此函数会在A中被执行
{//do somethingprintf("B得到A的数据 = %d\n",data);
}int main(void) {// 启动Astartup_app_A();SetCallBackFun(recieve);// 主函数while (1) {printf("main function\n");sleep(2);}return 0;
}
PS D:\Work\c++> ./bin/app
SetCallBackFun print! 
main function
main function
B得到A的数据 = 0
main function
main function
B得到A的数据 = 1
main function
B得到A的数据 = 2
main function
main function
B得到A的数据 = 3
main function
B得到A的数据 = 4
main function
main function
B得到A的数据 = 5
main function
B得到A的数据 = 6
main function
B得到A的数据 = 7
main function
main function
B得到A的数据 = 8
main function
B得到A的数据 = 9
main function
PS D:\Work\c++> cmake --build build
[100%] Built target app
PS D:\Work\c++> ./bin/app
SetCallBackFun print! 
main function
main function
B得到A的数据 = 0
main function
B得到A的数据 = 1
main function
main function
B得到A的数据 = 2
main function
B得到A的数据 = 3
main function
main function
B得到A的数据 = 4
main function
main function
B得到A的数据 = 5
main function
B得到A的数据 = 6
main function
main function
B得到A的数据 = 7
main function
B得到A的数据 = 8
main function
main function
B得到A的数据 = 9
main function
B得到A的数据 = 0
main function
main function
B得到A的数据 = 1
main function
B得到A的数据 = 2
main function
B得到A的数据 = 3
main function
main function
B得到A的数据 = 4
main function
B得到A的数据 = 5
main function
main function
B得到A的数据 = 6
main function
B得到A的数据 = 7
main function
main function
B得到A的数据 = 8
main function
B得到A的数据 = 9
main function
main function
B得到A的数据 = 0
main function
B得到A的数据 = 1
main function
main function
B得到A的数据 = 2
main function
B得到A的数据 = 3
main function
main function
B得到A的数据 = 4
main function
B得到A的数据 = 5
main function
main function
B得到A的数据 = 6
main function
B得到A的数据 = 7
main function
main function
B得到A的数据 = 8
main function
B得到A的数据 = 9
main function
main function
B得到A的数据 = 0
main function
B得到A的数据 = 1
main function
main function
B得到A的数据 = 2
main function
B得到A的数据 = 3
main function
main function
B得到A的数据 = 4
main function
B得到A的数据 = 5
main function
main function
B得到A的数据 = 6
main function
B得到A的数据 = 7
main function
main function
B得到A的数据 = 8
main function
B得到A的数据 = 9
main function
main function
B得到A的数据 = 0
main function
B得到A的数据 = 1
main function
main function
B得到A的数据 = 2
main function
B得到A的数据 = 3
main function
main function
B得到A的数据 = 4
main function
B得到A的数据 = 5
main function
main function
B得到A的数据 = 6
main function
B得到A的数据 = 7
main function
main function
B得到A的数据 = 8
main function
B得到A的数据 = 9
main function
main function
B得到A的数据 = 0
main function
B得到A的数据 = 1
main function
main function
B得到A的数据 = 2
main function
B得到A的数据 = 3
main function
main function
B得到A的数据 = 4
main function
B得到A的数据 = 5
main function
main function
B得到A的数据 = 6
main function
B得到A的数据 = 7
main function
main function
B得到A的数据 = 8

参考文章：

c++ 用std::function包装类的非静态成员_c++ function 绑定非静态成员函数-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/weixin_62953519/article/details/128438241

未完待续 ~

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/450884.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

政安晨：示例演绎Python的列表

政安晨：示例演绎Python的列表

列表和你可以用它们做的事&#xff1a;包括索引、切片和对象变动 (变异-Mutation) 。 列表 在Python中&#xff0c;列表表示有序的值序列。以下是如何创建列表的示例&#xff1a; primes [2, 3, 5, 7] 我们可以将其他类型的元素放在列表中&#xff1a; planets [Mercury…
阅读更多...
股票交易

股票交易

这里尝试利用单调队列优化&#xff0c;这里不好直接用单调队列的原因是因为(以买为例)\(-ap[i]*k_1\)不是只与下标有关的 所以解决方案一&#xff1a;我们将下标变成一个整体&#xff0c;再把后面的代价换掉然后将与下标无关的直接提出去 解决方案二&#xff1a;利用“蚯蚓”那…
阅读更多...
深入了解 Ansible：全面掌握自动化 IT 环境的利器

深入了解 Ansible：全面掌握自动化 IT 环境的利器

本文以详尽的篇幅介绍了 Ansible 的方方面面&#xff0c;旨在帮助读者从入门到精通。无论您是初学者还是有一定经验的 Ansible 用户&#xff0c;都可以在本文中找到对应的内容&#xff0c;加深对 Ansible 的理解和应用。愿本文能成为您在 Ansible 自动化旅程中的良师益友&#…
阅读更多...
自学网安-IIS服务器

自学网安-IIS服务器

部署环境&#xff1a;win2003 配置环境&#xff1a;winxp ip&#xff1a;10.1.1.2 win2003 ip&#xff1a;10.1.1.1 开始安装 双击“应用程序服务器” 双击“Internet 信息服务&#xff08;IIS&#xff09;” 勾选万维网服务&#xff0c;确定然后下一步 查看端口号;netstat …
阅读更多...
Fink CDC数据同步（三）Flink集成Hive

Fink CDC数据同步（三）Flink集成Hive

1 目的 持久化元数据 Flink利用Hive的MetaStore作为持久化的Catalog&#xff0c;我们可通过HiveCatalog将不同会话中的 Flink元数据存储到Hive Metastore 中。 利用 Flink 来读写 Hive 的表 Flink打通了与Hive的集成&#xff0c;如同使用SparkSQL或者Impala操作Hive中的数据…
阅读更多...
阻塞队列（超详细易懂）

阻塞队列（超详细易懂）

目录 一、阻塞队列 1.阻塞队列概述 2.生产者消费者模型 3.阻塞队列的作用 4.标准库中的阻塞队列类 5.例子&#xff1a;简单生产者消费者模型 二、阻塞队列模拟实现 1.实现循环队列&#xff08;可跳过&#xff09; 1.1简述环形队列 1.2代码实现 2.实现阻塞队列 2.1实…
阅读更多...
[基础IO]文件描述符{重定向/perror/磁盘结构/inode/软硬链接}

[基础IO]文件描述符{重定向/perror/磁盘结构/inode/软硬链接}

文章目录 1. 再识重定向2.浅谈perror()3.初始文件系统4.软硬链接 1. 再识重定向 图解./sf > file.txt 2>&1 1中内容拷贝给2 使得2指向file 再学一个 把file的内容传给cat cat拿到后再给file2 2.浅谈perror() open()接口调用失败返回-1,并且错误码errno被适当的设置,…
阅读更多...
回归预测 | Matlab实现CPO-CNN-LSTM-Attention冠豪猪优化卷积长短期记忆神经网络注意力机制多变量回归预测（SE注意力机制）

回归预测 | Matlab实现CPO-CNN-LSTM-Attention冠豪猪优化卷积长短期记忆神经网络注意力机制多变量回归预测（SE注意力机制）

回归预测 | Matlab实现CPO-CNN-LSTM-Attention冠豪猪优化卷积长短期记忆神经网络注意力机制多变量回归预测&#xff08;SE注意力机制&#xff09; 目录 回归预测 | Matlab实现CPO-CNN-LSTM-Attention冠豪猪优化卷积长短期记忆神经网络注意力机制多变量回归预测&#xff08;SE注…
阅读更多...
Linux下grep命令详解

Linux下grep命令详解

grep #文件内容过滤显示 #在指定的普通文件中查找并显示含有指定字符串的行&#xff0c;也可与管道符一起使用格式&#xff1a; grep-参数 查找条件 文件名 参数&#xff1a; 示例&#xff1a; [rootnode1 ~]# grep -n "root" /etc/passwd # -n&a…
阅读更多...
070：vue中provide、inject的使用方法（图文示例）

070：vue中provide、inject的使用方法（图文示例）

第070个 查看专栏目录: VUE 本文章目录 示例背景示例效果图示例源代码父组件代码子组件代码孙组件代码 基本使用步骤 示例背景 本教程是介绍如何在vue中使用provide和inject。在 Vue 中&#xff0c;provide 和 inject 是用于实现祖先组件向后代组件传递数据的一种方式。 在这个…
阅读更多...
【Nginx】Nginx

【Nginx】Nginx

❤️ Author&#xff1a; 老九 ☕️ 个人博客&#xff1a;老九的CSDN博客 &#x1f64f; 个人名言&#xff1a;不可控之事 乐观面对 &#x1f60d; 系列专栏&#xff1a; 文章目录 公司产品出现瓶颈Nginx作用Nginx安装window下安装linux下安装 Nginx常用命令 公司产品出现瓶颈 …
阅读更多...
BGP协议

BGP协议

1.BGP相关概念 1.1 BGP的起源 不同自治系统&#xff08;路由域&#xff09;间路由交换与管理的需求推动了EGP的发展&#xff0c;但是EGP的算法简单&#xff0c;无法选路&#xff0c;从而被BGP取代。 自治系统&#xff1a;&#xff08;AS&#xff09; IGP&#xff1a;自治系统…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023