c++ - 这个回调有什么问题？

Question

这是我的 code :

#include <iostream>
#include <stdio.h>

using namespace std;

typedef void (*CallbackType)(double); 

class LFO
{
private:

public:
    CallbackType target;

    inline void Process() {
        double value = 1.3;
        target(value);
    }
};

class ExternalObject
{
private:

public:
    double mTest = 1.0;

    ExternalObject() {

    }
    ~ExternalObject() {

    }

    inline void PrintValue(double value) {
        cout << "passed: " << value << endl;
    }
};

int main ()
{
    ExternalObject eo;
    LFO lfo;

    lfo.target = eo.PrintValue;
    lfo.Process();
}

我想在 LFO 的 Process 中执行 ExternalObject 的回调 PrintValue。但我似乎无法通过这种方式传递 lfo.target ？我哪里错了？ (抱歉，我是 C++ 的新手；在 JavaScript 中，我将采用这种方式)。

Answer 1

CallbackType定义如下:

typedef void (*CallbackType)(double); 

这基本上是一个接受 double 的函数并且什么都不返回(void)。

当您分配 eo.PrintValue 时像这样:

lfo.target = eo.PrintValue;

你的类型不匹配:那是因为 PrintValue是 ExternalObject 的非静态成员函数类(class)。非静态成员函数有一个“隐藏” 附加参数，即this指向类实例的指针。

这有点像 PrintValue 的实际声明会是:

void ExternalObject::PrintValue(ExternalOject* this, double value) 

你可以解决这个问题 PrintValue static ExternalObject的方法 , 作为 static方法没有额外的 this指针参数。例如:

class ExternalObject {
 public:
  // Note: you don't need "inline" here
  static void PrintValue(double value) {
     ...
  }

---

P.S. 通常当你有回调时，C++ 中的一个常见模式是提供额外的 void*回调中的参数。这可用于为回调函数提供一些上下文，包括传递上述 this指针(因此静态成员函数回调可以使用 this 指针来调用非静态方法)。

P.P.S. 这种回调风格通常出现在 C 接口(interface) API 中。在 C++ 中，您可能需要考虑 std::function (例如 std::function<void(double)>)。

---

您还可以考虑使用重载 operator() 类的设计作为回调(所谓的“仿函数”，或“函数对象”)，例如:

#include <functional>  // for std::function
#include <iostream>

class LFO {
public:
    std::function<void(double)> Target;

    void Process() {
        double value = 1.3;
        Target(value);
    }
};

class ValuePrinter {
public:
    void operator()(double value) const {
        std::cout << "passed: " << value << '\n';
    }
};

int main() {
    LFO lfo;
    lfo.Target = ValuePrinter();
    lfo.Process();
}

---

作为另一种选择，您可以使用 std::bind 和 double 的占位符参数，例如里面main :

ExternalObject eo;
LFO lfo;

using namespace std::placeholders;
lfo.Target = std::bind(&ExternalObject::PrintValue, &eo, _1);
lfo.Process();

可编译代码:

#include <functional>
#include <iostream>

class LFO {
public:
    std::function<void(double)> Target;

    void Process() {
        double value = 1.3;
        Target(value);
    }
};

class ExternalObject {
public:
    double mTest = 1.0;

    ExternalObject() = default;

    void PrintValue(double value) {
        std::cout << "passed: " << value << '\n';
    }
};

int main() {
    ExternalObject eo;
    LFO lfo;

    using namespace std::placeholders;
    lfo.Target = std::bind(&ExternalObject::PrintValue, &eo, _1);
    lfo.Process();
}