C++回调

目录

• 1、回调（callback）：
  • 函数指针回调：
  • 函数对象回调：
  • Lambda表达式回调：
• 2、对象绑定器（Binders）：
• 3、包装器（Wrappers）：

1、回调（callback）：

在C++中，回调（callback）是指一种将一个函数作为参数传递给另一个函数，并在该函数执行的过程中执行传递进来的函数的机制。回调通常用于实现一种灵活的、可扩展的代码结构，其中某个函数需要在特定的事件发生时执行某些操作，但具体要执行的操作是由调用者提供的。

常见的回调模式包括：函数指针、函数对象、Lambda表达式等。

函数指针回调：

// 函数指针类型定义
typedef void (*CallbackFunction)(int);

// 接受函数指针作为参数的函数
void performOperation(int value, CallbackFunction callback)
{
    // 执行某些操作
    // ...

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

// 使用回调的示例
void myCallbackFunction(int result)
{
    std::cout << "Callback received result: " << result << std::endl;
}

// 调用函数，并传递回调函数
performOperation(42, myCallbackFunction);

函数对象回调：

// 函数对象定义
class MyCallback
{
public:
    void operator()(int result)
    {
        std::cout << "Callback received result: " << result << std::endl;
    }
};

// 接受函数对象作为参数的函数
void performOperation(int value, MyCallback callback)
{
    // 执行某些操作
    // ...

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

// 使用回调的示例
MyCallback myCallback;
performOperation(42, myCallback);

Lambda表达式回调：

// 使用 Lambda 表达式的回调
void performOperation(int value, std::function<void(int)> callback)
{
    // 执行某些操作
    // ...

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

// 使用回调的示例
performOperation(42, [](int result){
    std::cout << "Callback received result: " << result << std::endl;
});

回调的主要优势使代码更具有灵活性，因为它允许调用者在运行时提供具体的行为，而不是在编译时硬编码。这种模式在事件处理、异步编程和设计模式中经常使用。

在C++中，对象绑定器和包装器是用于函数操作的工具。它们用于将函数与参数绑定在一起，以便稍后执行或者传递给其他地方。这样的工具提供了更灵活的方式来管理函数调用和参数传递。

2、对象绑定器（Binders）：

C++中的对象绑定器通常指的是std::bind，它是函数模板，用于将函数和一部分参数绑定在一起。std::bind可以用于创建函数对象，其中一些参数的值已经被绑定，而另一些参数可以在稍后传递。

#include <iostream>
#include <functional>

void myFunction(int a, int b, int c)
{
    std::cout << "Sum: " << (a + b + c) << std::endl;
}

int main()
{
    auto binder = std::bind(myFunction, 10, std::placeholders::_1, std::placeholders::_2);

    binder(20, 30);  // 输出 Sum: 60

    return 0;
}

在上面的例子中，std::bind将myFunction与参数10绑定在一起，然后创建了一个可调用的函数对象binder。在调用binder时，可以传递剩余的两个参数。

3、包装器（Wrappers）：

C++中的包装器通常指的是std::function，它是一个函数对象的封装器，可以包装任何可以调用的目标，例如函数指针、函数对象、Lambda表达式等。

#include <iostream>
#include <functional>

void myFunction(int a, int b, int c)
{
    std::cout << "Sum: " << (a + b + c) << std::endl;
}

int main()
{
    std::function<void(int, int, int)> wrapper = myFunction;

    wrapper(10, 20, 30);  // 输出 Sum: 60

    return 0;
}

在上面的例子中，std::function创建了一个包装器wrapper，它可以接受与myFunction具有相同签名的任何可调用对象。这使得wrapper可以用来封装函数、函数对象等，并在稍后执行。