学习回调函数回调函数是通过函数指针或对象调用的函数。回调函数就是通过函数指针或对象调用的函数只要能一个函数能够作为参数传入并调用这个函数就是回调函数。#include iostream int addCallBack(int a,int b){//回调函数 std::cout abstd::endl; return 0; } int main(int argc, char** argv) { int(*p)(int,int); p addCallBack; p(1,2); return 0; }为什么使用回调函数前言里直接在main函数调用addCallBack不是更直接吗为什么要使用函数指针接收addCallBack的地址再调用呢回调函数通常是为了实现“控制反转”Inversion of Control 灵活、分离、 异步与并发。解耦和模块化 函数与具体的逻辑解耦可以复用。// 排序算法不关心具体比较逻辑 void sort(int* arr, int n, bool(*compare)(int, int)) { for (int i 0; i n-1; i) { //解耦和模块化 for (int j i1; j n; j) { if (compare(arr[i], arr[j])) { std::swap(arr[i], arr[j]); } } } } // 不同的比较策略 bool ascending(int a, int b) { return a b; } bool descending(int a, int b) { return a b; } int main() { int data[] {5, 2, 8, 1, 3}; sort(data, 5, ascending); // 升序 sort(data, 5, descending); // 降序 return 0; }异步处理我不知道什么时候能算完#include thread #include functional #include iostream // 模拟异步任务 void asyncTask(std::functionvoid(int) callback) { std::thread([callback]() { std::this_thread::sleep_for(std::chrono::seconds(2)); int result 42; // 模拟计算结果 callback(result); // 完成后通过回调通知 }).detach(); } // 回调处理结果 void handleResult(int result) { std::cout 异步任务完成结果: result std::endl; } int main() { std::cout 开始异步任务... std::endl; asyncTask(handleResult); // 非阻塞调用 // 主线程可以继续做其他事情 for (int i 0; i 5; i) { std::cout 主线程工作... i std::endl; std::this_thread::sleep_for(std::chrono::milliseconds(500)); } return 0; }实现函数指针实现普通函数调用#include iostream //回调函数 无参 void callBack(){ std::cout无参回调函数std::endl; } //回调函数 带参数 void callback_ii(int a,int b){ std::coutabstd::endl; } //回调函数带返回值 int callback_return_i(){ int a 10; return a; } /* 定义函数指针 */ //无参 函数指针 typedef void(*CallbackPtr)(); // 它是指向返回void接受两个int参数的函数的指针类型 typedef void (*CallbackPtr_ii)(int, int); // using CallbackPtr_using void(*)(int, int); //带返回值 函数指针 typedef int(*CallbackPtr_return_i)(); void performTask(CallbackPtr cb) { cb(); // 执行回调 } void performTask_ii(int a, int b, CallbackPtr_ii cb) { // 业务逻辑... cb(a, b); // 执行回调 } void performTask_return_i(CallbackPtr_return_i cb) { // 业务逻辑... std::cout cb() std::endl; } int main(){ performTask(callBack); performTask_ii(1,2,callback_ii); performTask_return_i(callback_return_i); return 0; }这里其实就是使用指针调用函数。void (*p)(int ,int);p callback;//p callback;(*p)(0,1);//p(0,1);类成员函数和类静态函数调用#include iostream class MyClass { public: void Func(){ std::cout function std::endl; } static void staticFunc() { std::cout Static function std::endl; } }; int main() { void (*staticFuncPtr)() MyClass::staticFunc; staticFuncPtr(); // 输出: Static function /* void (*funcPtr)() MyClass::Func;//error: cannot convert ‘void (MyClass::*)()’ to ‘void (*)()’ in initialization funcPtr(); */ // 指向普通成员函数 - 需要特殊的语法 MyClass MyObj; void (MyClass::*FuncPtr)() MyClass::Func; // 声明成员函数指针 (MyObj.*FuncPtr)(); // 通过对象调用输出: function return 0; }Class A 调用 Class B#include iostream class ProgramA { public: void Func(void (*callback)()) { std::cout A: callback std::endl; callback(); } }; class ProgramB { public: void Func() { std::cout B: function std::endl; } static void staticFunc() { std::cout B: Static function std::endl; } }; int main() { ProgramA PA; PA.Func(ProgramB::staticFunc); return 0; }如何使用A调用B中的非静态方法这里只写两种方式。方式一使用function修改A的调用函数。方式二在A中修改参数#include iostream #include functional class ProgramB; class ProgramA { public: //方式一 void Func(std::functionvoid() callback) { std::cout A std::functionvoid(): callback std::endl; callback(); } //方式二 void Func(void(ProgramB::*callback)(),void *PBPtr){ std::cout A void(ProgramB::*callback)(): callback std::endl; ((ProgramB*)PBPtr-*callback)();//*不是解引用而是指针到成员运算符 -* 的一部