回调函数

定义

回调函数是一种通过函数指针或者函数对象传递给另一个参数，并在特定事件或条件下被调用的函数。

举例

#include<stdio.h>
//回调函数类型定义,函数对象的返回值、名字和参数
typedef void (*myCallback)(int);
//执行计算的函数
void calculatesum(int a,int b,myCallback callback){
	int sum = a + b
	//调用回调函数，将结果传递给回调函数
	callback(sum);
}
//回调函数实现
void printSum(int sum){
	printf("计算结果为: %d\n",sum);
}
int main(){
	//调用cacculatesum函数，并将printsum函数作为回调函数传递
	calculateSum(6,2,printsum);
	return 0;
}

这样在执行calculateSum函数的时候，在函数内部计算完成之后，就会调用传递的回调函数printSum，同时将计算的结果传递给它，最后，printSum函数就会将结果打印到控制台上。

使用场景

• 事件处理：在一些事件驱动的场景中，回调函数可以用来处理一些特定事件的发生，比如在图形用户界面的编程场景中，鼠标的点击、鼠标的移动等事件就可以通过
  注册回调函数，当有上述的事件发生的时候就会调用对应的回调函数。
• 异步编程：在一些异步编程的场景中，回调函数可以用来处理一些异步操作的结果。不如文件的读写、网络数据的传输等异步操作，当操作完成之后，自动调用
  已经注册好的回调函数。
• 定时器：可以通过注册对应的回调函数来在特定的时间间隔内或者在特定的时间点执行某一操作。当定时器被触发的时候。系统就会调用对应的回调函数。

回调函数常用于处理事件驱动的编程模型。在这种模型中，当特定事件发生时，系统会自动调用注册的回调函数来处理事件。这种机制使得程序能够实时响应事件，提高了系统的并发性和响应性。

注意事项

• 参数和返回值：确保回调函数的参数和返回值与调用方的参数类型和返回值相匹配；
• 内存管理：如果调用函数涉及到内存的动态分配，那么需要确保在适当的时候释放内存，避免内存泄漏；
• 嵌套过多：避免嵌套过多的回调函数。

回调函数的好处就是解耦。
目的就是减少模块与模块之间的依赖。

// 使用回调函数实现解耦
// .cpp1
#include <iostream>
#include <functional>

// 模块A：处理数据并调用回调函数
class ModuleA {
public:
    void processData(int data, std::function<void(int)> callback) {
        // 处理数据
        data *= 2;
        // 调用回调函数
        callback(data);
    }
};

// .cpp2
#include <iostream>

// 模块B：实现回调函数
class ModuleB {
public:
    void onDataProcessed(int result) {
        std::cout << "ModuleB received processed data: " << result << std::endl;
    }
};

// main.cpp
#include <iostream>
#include <functional>

// 引入模块A和模块B
#include "ModuleA.h"
#include "ModuleB.h"

int main() {
    ModuleA moduleA;
    ModuleB moduleB;

    // 使用Lambda表达式将ModuleB的成员函数传递给ModuleA
    moduleA.processData(5, [&moduleB](int result) {
        moduleB.onDataProcessed(result);
    });
    return 0;
}

//模块A：负责数据处理，并在处理完成后调用回调函数。
//模块B：实现回调函数，用于处理数据处理完成后的逻辑。
//主程序：将模块B的回调函数传递给模块A，实现模块之间的解耦。

//使用普通函数没有解耦
// .cpp1
#include <iostream>

// 模块A：处理数据并直接调用模块B的函数
class ModuleA {
public:
    void processData(int data) {
        // 处理数据
        data *= 2;

        // 直接调用模块B的函数
        moduleB.onDataProcessed(data);
    }

    void setModuleB(ModuleB& b) {
        moduleB = b;
    }

private:
    ModuleB moduleB;
};

// .cpp2
#include <iostream>

// 模块B：实现回调函数
class ModuleB {
public:
    void onDataProcessed(int result) {
        std::cout << "ModuleB received processed data: " << result << std::endl;
    }
};

// main.cpp
#include <iostream>

// 引入模块A和模块B
#include "ModuleA.h"
#include "ModuleB.h"

int main() {
    ModuleA moduleA;
    ModuleB moduleB;

    // 设置模块B到模块A中
    moduleA.setModuleB(moduleB);

    // 处理数据
    moduleA.processData(5);

    return 0;
}

//模块A：负责数据处理，并在处理完成后直接调用模块B的函数。
//模块B：实现数据处理完成后的逻辑。
//主程序：将模块B的实例传递给模块A。

对比：

• 耦合性：
  使用回调函数：模块A和模块B之间没有直接依赖关系，模块A只需要知道回调函数的接口，而不需要知道模块B的具体实现。
  使用普通函数：模块A直接依赖于模块B，模块A需要知道模块B的具体实现，增加了耦合性。
• 灵活性：
  使用回调函数：可以轻松替换或修改回调函数的实现，而不需要修改模块A的代码。
  使用普通函数：如果需要修改模块B的实现，可能需要修改模块A的代码，降低了灵活性。
• 可维护性：
  使用回调函数：代码更加模块化和易于维护，因为每个模块的职责更加明确。
  使用普通函数：代码的维护难度增加，因为模块之间的依赖关系更加紧密。