将方法作为回调从一个类传递到另一个类

Question

我有 2 个类，我想通过回调将一个方法从一个传递到另一个！

看到我也希望使用 void (*callBack)(); 来保存这个方法的地址

我习惯用C做这个，但我不知道如何用c++做这个；

#include <iostream>

using namespace std;

class A
{
    private:
        void (*callBack)(); //to hold the address of the method

    public:
        A();
        void setCallBack(void(*cB)());
        void useCallBack();
};


A::A()
{

}

void A::setCallBack(void(*cB)())
{
    callBack = cB;
}

void A::useCallBack()
{
    callBack();
}


class B
{
    private:
        A * Aguy;

    public:
        B();
        void someMethod();
        void otherMethod();
};

B::B()
{
    Aguy = new A();
}

void B::otherMethod()
{
    Aguy->setCallBack(someMethod);
    Aguy->useCallBack()
}

void B::someMethod()
{
    cout << "Hello. I'm from class b" << endl;
}

int main()
{
    B Bguy;
    Bguy.otherMethod();

    return 0;
}

Answer 1

问题是：

    void (*callBack)();

这不是指向方法的指针。这是一个指向函数的指针。
要获得指向方法的指针，您需要指定该方法所在的类。

    void (B::*callBack)();

那么当你调用它时，你需要通过一个对象来调用它。

 void A::useCallBack(B* b)
 {
      (b->*callBack)();
 }

但这可能不是你想要的。
你真正想要的是一个封装所有这些的包装器。

我会看看 std::function。这将允许您将一个方法调用和一个对象包装到一个可以调用的对象中。

std::function<void()>   callback;

只需将所有出现的void(*cB)() 替换为std::function<void()>，然后您就可以将对象的实例绑定到调用点的方法。

Aguy->setCallBack(std::bind(&B::someMethod, this));

这还允许您将任何普通函数或仿函数作为回调传递。

void print()
{    std:cout << "It worked\n";
}
...
Aguy->setCallBack(&print);

struct Printer
{
     void operator()() const
     {
         std::cout << "It worked with  obejct\n";
     }
}
...
Aguy->setCallBack(Printer());

Answer 2

如果您需要传递成员函数指针，请参阅修改后的代码。它使用现代 c++ 结构。

#include <iostream>
#include <functional>
using namespace std;


class A
{
private:
    typedef std::function<void()> some_void_function_type;
    some_void_function_type f_;
public:
    A();
    void setCallBack(some_void_function_type f);
    void useCallBack();
};


A::A()
{

}

void A::setCallBack(some_void_function_type f)
{
    f_ = f;
}

void A::useCallBack()
{
    f_();
}


class B
{
private:
    A * Aguy;

public:
    B();
    void someMethod();
    void otherMethod();
};

B::B()
{
    Aguy = new A();
}

void B::otherMethod()
{
    Aguy->setCallBack(std::bind(&B::someMethod, this));
    Aguy->useCallBack();
}

void B::someMethod()
{
    cout << "Hello. I'm from class b" << endl;
}

int main()
{
    B Bguy;
    Bguy.otherMethod();

    return 0;
}

Answer 3

详情请见c++ - <unresolved overloaded function type>。

引用答案：

在 C++ 中，成员函数有一个隐式参数，它指向 对象（成员函数内的 this 指针）。正常 C 函数可以被认为具有不同的调用约定 从成员函数，所以他们的指针的类型 （指向成员函数的指针与指向函数的指针）是不同的，并且 不相容。 C++ 引入了一种新类型的指针，称为 指向成员的指针，只能通过提供对象来调用。

把静态放在someMethod上：

class B
{
    private:
        A * Aguy;

    public:
        B();
        static void someMethod();
        void otherMethod();
};

void B::otherMethod() {
    Aguy->setCallBack(B::someMethod);
    Aguy->useCallBack(); // adding missing semicolon
}