什么是回调？ 它的用途是什么以及如何在例如 C++ 中实现？

Question

我意识到这是一个新手问题，但当我尝试学习 C++ 时，我经常遇到这个表达式“回调”。 我用谷歌搜索并检查了维基百科，但没有找到很好的解释。 我熟悉一些 Java 和 C#，但这听起来多么不可能，我从来没有真正理解回调的含义。

如果有人知道如何向一个简单的外行解释这个术语，我将非常感激。

Answer 1

我熟悉一些Java和C#

回调是这些语言中的事件或委托 - 一种让您的代码在其上下文中由其他人的代码运行的方法。 因此，术语“回调”：

1. 您调用其他一段代码
2. 它运行，也许计算一个中间值
3. 它回调到您的代码，也许给您该中间值
4. 将控制权传递回给您

它继续运行，最终通过完成规范 示例是带有用户定义的比较函数（回调）的排序例程。 给定一个排序例程，例如：（

void Sort(void* values, int length, int valueSize, 
          int (*compare)(const void*, const void*) 
{
   for (int i = 0; i < length; i = i + 2) {
      // call the callback to determine order
      int isHigher = compare(values[i], values[i + 1]);
      /* Sort */
   }
}

如何执行排序的细节并不重要 - 只需关注以下事实：任何排序算法都需要比较 2 个值并确定哪个值更高。

） ，现在我们可以定义一些比较函数：

int CompareInts(const void* o, const void* p) {
   int* a = (int*) o;
   int* b = (int*) p;

   if (a == b) return 0;
   return (a < b) ? -1 : 1;
}

int ComparePersons(const void* o, const void* p) {
   Person* a = (Person*) o;
   Person* b = (Person*) p;

   if (a == b) return 0;
   return (a->Value() < b=>Value()) ? -1 : 1;
}

并与它们重用相同的排序函数：

int intValues[10];
Person personValues[10];

Sort(intValues, 10, sizeof(intVaues[0]), CompareInts);
Sort(personValues, 10, sizeof(personVaues[0]), ComparePersons);

如果您使用成员函数，事情会变得有点复杂，因为您必须管理 this 指针 - 但概念是一样的。 与大多数事情一样，首先用 C 语言解释它们会更容易。 ;)

Answer 2

当您向回调发送某些内容时，您会以一种寻址的方式发送函数（例如，C++ 中的函数指针），以便您将其发送到的代码稍后可以调用该函数，当它已经完成了一些过程。

之间的区别

start_some_process(some_value, some_function())   # not using a callback

和

start_some_process(some_value, some_function)     # using a callback

在于，在第一个实例中，您发送函数的结果，而在第二个实例中，您发送函数本身。

Answer 3

这有您的答案和代码参考：回调

Answer 4

回调是正在执行的代码中的挂钩，允许您在流程中的已知点提供自定义功能。 它允许通用控制结构执行由从其中调用的代码指定的自定义操作，因此术语“回调” - 它回调到您的代码中。

通常，这是通过提供具有特定预定义签名的函数指针来完成的，并且执行回调的通用代码将参数传递给您的函数并期望某种类型的返回值。

这是一个非常强大的模式，允许代码重用和相当简单的定制/扩展，而无需完全重写。

自定义排序函数就是一个很好的例子。 排序算法是通用的，比较函数特定于正在排序的内容。 许多算法允许您提供一个函数，该函数接受两个泛型类型的参数（作为要比较的对象），并期望您根据比较结果返回 +ve、-ve 或零值。

然后，您自己编写 comaprison 函数，并提供一个指向排序算法的函数指针，该算法在排序过程中“回调”。

Answer 5

用最简单的术语来说，回调是传递给另一个方法的代码。

例如，您有一个类 A，它调用类 B 上的方法，但您需要在 A 类完成后运行一些代码。 您将代码放入类 A 上自己的新方法中，并在调用类 B 上的方法时传递方法名称。当类 B 上的方法完成其工作后，它可以“回调”到类 A 中。

现在，您实际上不需要将回调代码放入其自己的方法中：您可以使用匿名方法和 lambda 表达式。 我认为在掌握匿名方法之前学习使用匿名方法可能最不会令人困惑（至少在 C# 中）。

祝你好运！

PS 我也是一样：在我真正理解 C# 之前，我已经编码了很多年。

Answer 6

在 C++ 中查看 boost::function

http://www. boost.org/doc/libs/1_39_0/doc/html/function.html

Answer 7

我为另一个问题发布了这个答案，但它似乎同样适用于此。

以下是在 C++ 中实现回调的方法，从（大致）最灵活到最不灵活

： ）

此处列出了几种信号和槽的实现（特别是 Boost.Signal 。 这些对于实现观察者设计模式很有用，其中多个对象有兴趣接收通知。

Boost.Function

你可以注册一个 boost::function< /code>回调。 boost::function 是任何可调用实体的包装：自由函数、静态函数、成员函数或函数对象。 要包装成员函数，请使用 boost::bind 如本 示例所示。 用法示例：

#include <iostream>
#include <boost/function.hpp>
#include <boost/bind.hpp>

typedef boost::function<void (void)> MouseCallback;

class Mouse
{
public:
    void registerCallback(MouseCallback callback) {callback_ = callback;}

    void notifyClicked() {if (callback_) callback_();}

private:
    MouseCallback callback_;
};

class Foo
{
public:
    void mouseClicked() {std::cout << "Mouse clicked!";}
};

int main()
{
    Mouse mouse;
    Foo foo;
    mouse.registerCallback(boost::bind(&Foo::mouseClicked, &foo));
    mouse.notifyClicked();
}

Fast Delegate

有一个名为 FastDelegate 的委托实现，它比boost::function。 它使用了 C++ 标准不支持的“丑陋的 hack”，但几乎所有编译器都支持。

标准还支持不可能的快速 C++ 委托，但不支持由所有编译器。

“监听器”接口（抽象类）

您可以注册一个指向从回调接口（抽象类）派生的对象的指针。 这是执行回调的传统 Java 方式。 示例：

class MouseInputListener
{
public:
    virtual void mouseClicked() = 0;
    virtual void mouseReleased() = 0;
};

class Mouse
{
public:
    Mouse() : listener_(0) {}
    void registerListener(MouseInputListener* listener) {listener_ = listener;}
    void notifyClicked() {if (listener_) listener_->mouseClicked();}
    void notifyReleased() {if (listener_) listener_->mouseReleased();}

private:
    MouseInputListener* listener_;
};

class Foo : public MouseInputListener
{
public:
    virtual void mouseClicked() {cout << "Mouse clicked!";}
    virtual void mouseReleased() {cout << "Mouse released!";}
};

C 样式回调

您注册一个指向回调自由函数的指针，以及一个附加的“上下文”void 指针。 在回调函数中，您将 void* 转换为将处理事件的对象类型，并调用正确的方法。 例如：

typedef void (*MouseCallback)(void* context); // Callback function pointer type

class Mouse
{
public:
    Mouse() : callback_(0), context_(0) {}

    void registerCallback(MouseCallback callback, void* context = 0)
        {callback_ = callback; context_ = context;}

    void notifyClicked() {if (callback_) callback_(context_);}

private:
    MouseCallback callback_;
    void* context_;
};

class Foo
{
public:
    void mouseClicked() {cout << "Mouse clicked!";}

    static void callback(void* context)
        {static_cast<Foo*>(context)->mouseClicked();}
};

int main()
{
    Mouse mouse;
    Foo foo;
    mouse.registerCallback(&Foo::callback, &foo);
    mouse.notifyClicked();
}

基准测试

我发现了一些性能基准测试：

• http://www.ce.unipr .it/~medici/boostbenchmark.html
• http://www.kbasm. com/cpp-callback-benchmark.html

它们应该让您了解哪种回调机制适合不同的性能要求。

从数字中可以看出，Boost 信号必须每秒调用 10,000 到 100,000 次，性能才会成为问题。