Question

我想做以下事情：我有两个类，A和B，并希望将A中的函数绑定到B中的函数，这样无论什么时候调用B中的函数，都会调用A中的函数。

基本上，这就是场景：（重要 A和B应该是独立的类）

这将是A类：

class A {
private:
    // some needed variables for "doStuff"
public:
    void doStuff(int param1, float *param2);
}

这是B级

class B {
private:
    void callTheFunction();

public:
    void setTheFunction();   

}

这就是我想要使用这些类的方法：

B *b = new B();
A *a = new A();

b->setTheFunction(a->doStuff); // obviously not working :(

我已经读过这可以通过std :: function来实现，这将如何工作？此外，只要调用callTheFunction()，这会对性能产生影响吗？在我的例子中，它是一个音频回调函数，它应该调用另一个类的样本生成函数。

Answer 1

这是一个基本的骨架：

struct B
{
    A * a_instance;
    void (A::*a_method)(int, float *);

    B() : a_instance(nullptr), a_method(nullptr) {}

    void callTheFunction(int a, float * b)
    {
        if (a_instance && a_method)
        {
            (a_instance->*a_method)(a, b);
        }
    }
};

用法：

A a;

B b;
b.a_instance = &a;
b.a_method = &A::doStuff;

b.callTheFunction(10, nullptr);

Answer 2

基于用法的解决方案C ++ 11 std :: function和std :: bind。

#include <functional>
#include <stdlib.h>
#include <iostream>

using functionType = std::function <void (int, float *)>;

class A
{
public:
    void doStuff (int param1, float * param2)
    {
        std::cout << param1 << " " << (param2 ? * param2 : 0.0f) << std::endl;
    };
};

class B
{
public:
    void callTheFunction ()
    {
        function (i, f);
    };

    void setTheFunction (const functionType specificFunction)
    {
        function = specificFunction;
    };

    functionType function {};
    int     i {0};
    float * f {nullptr};
};

int main (int argc, char * argv [])
{
    using std::placeholders::_1;
    using std::placeholders::_2;

    A a;
    B b;
    b.setTheFunction (std::bind (& A::doStuff, & a, _1, _2) );
    b.callTheFunction ();

    b.i = 42;
    b.f = new float {7.0f};
    b.callTheFunction ();

    delete b.f;
    return EXIT_SUCCESS;
}

编译：

$ g ++ func.cpp -std = c ++ 11 -o func

输出：

$ ./func

0 0

42 7

Answer 3

这是我基本的解决方案

class A {
private:
    // some needed variables for "doStuff"
public:
    void doStuff(int param1, float *param2)
    {

    }
};

typedef void (A::*TMethodPtr)(int param1, float *param2);

class B {
private:

    TMethodPtr m_pMethod;
    A* m_Obj;

    void callTheFunction()
    {
      float f;
      (m_Obj->*m_pMethod)(10, &f);
    }


public:
    void setTheFunction(A* Obj, TMethodPtr pMethod)
    {
       m_pMethod = pMethod;
       m_Obj = Obj;
    }
};

   void main()
   {
      B *b = new B();
      A *a = new A();
      b->setTheFunction(a, A::doStuff); // now work :)
   }

指向成员函数的指针

3 个答案: