c++ - 将一个类的方法指针存储到另一个类中

Question

我有类 A，它有方法 void fun(int, int) 和 void fun1(int, int)。这些是非静态方法。

struct A {
    void fun(int,int){}
    void fun1(int,int){}
};

现在在 B 类中，我想存储指向方法之一的指针。

这意味着 B 的 object1 将指向 fun 和 B 的 object2 code> 将有指向 fun1 的指针。

现在我的 set_handler() 和指向处理程序的指针必须是通用的。

一种方法是使用函数指针。这样我就可以使用 void(A::*pointer)(int,int) 来存储 fun 或 fun1 的地址。

struct B {
    typedef void(A::*pointer)(int,int);
    pointer f;

    void set_handler(pointer p) { f = p; }
};

int main() {
    {
        B object1;
        object2.set_handler(&A::fun);
    }
    {
        B object2;
        object2.set_handler(&A::fun1);
    }
}

我正在研究 boost::bind() 但它需要特定的名称。我如何在这里使用 boost？

Answer 1

我将你的问题转化为运行代码，该代码实际上对指针做了一些事情 - 所以我们知道何时实现了目标:

Live On Coliru

#include <iostream>

struct A {
    void fun(int  a, int b) { std::cout << __FUNCTION__ << "(" << a << "," << b << ")" << std::endl; }
    void fun1(int a, int b) { std::cout << __FUNCTION__ << "(" << a << "," << b << ")" << std::endl; }
};

struct B {
    typedef void (A::*pointer)(int, int);
    pointer f;

    void set_handler(pointer p) { f = p; }

    void run(A& instance) {
        (instance.*f)(42, 42);
    }
};

int main() {
    B object1;
    B object2;
    object1.set_handler(&A::fun);
    object2.set_handler(&A::fun1);

    A a;
    object1.run(a);
    object2.run(a);
}

打印

fun(42,42)
fun1(42,42)

使用boost::function 或std::function

您必须允许实例参数(隐式 this 参数):

Live On Coliru

struct B {
    using function = std::function<void(A&, int, int)>;
    function f;

    void set_handler(function p) { f = p; }

    void run(A& instance) {
        f(instance, 42, 42);
    }
};

打印相同的输出。当然你可以使用 boost::function 和 boost::bind 一样

绑定(bind)呢？

当您想要适应 函数签名时，绑定(bind)就派上用场了。所以，例如你想绑定(bind)到 A& 的任何实例，而不实际将它传递给 run():

Live On Coliru

#include <iostream>
#include <functional>

struct A {
    std::string name;
    void fun(int  a, int b) { std::cout << "name:" << name << " " << __FUNCTION__ << "(" << a << "," << b << ")" << std::endl; }
    void fun1(int a, int b) { std::cout << "name:" << name << " " << __FUNCTION__ << "(" << a << "," << b << ")" << std::endl; }
};

struct B {
    using function = std::function<void(int, int)>;
    function f;

    void set_handler(function p) { f = p; }

    void run() {
        f(42, 42);
    }
};

int main() {
    B object1;
    B object2;
    A a1 {"black"};
    A a2 {"white"};

    {
        using namespace std::placeholders;
        object1.set_handler(std::bind(&A::fun, &a1, _1, _2));
        object2.set_handler(std::bind(&A::fun1, &a2, _1, _2));
    }

    object1.run();
    object2.run();
}

打印:

name:black fun(42,42)
name:white fun1(42,42)

更多美好

在 C++ 中，您可以不用 bind 及其讨厌的占位符(还有其他注意事项，例如 bind 按值存储所有参数)。相反，您可以使用 lambda:

Live On Coliru

#include <iostream>
#include <functional>

struct A {
    std::string name;
    void fun(int  a, int b) { std::cout << "name:" << name << " " << __FUNCTION__ << "(" << a << "," << b << ")" << std::endl; }
    void fun1(int a, int b) { std::cout << "name:" << name << " " << __FUNCTION__ << "(" << a << "," << b << ")" << std::endl; }
};

struct B {
    using function = std::function<void(int, int)>;
    function f;

    void set_handler(function p) { f = p; }

    void run() {
        f(42, 42);
    }
};

int main() {
    B object1;
    B object2;

    object1.set_handler([](int a, int b) {
            A local_instance {"local"};
            local_instance.fun(a*2, b*3); // can even do extra logic here
        });

    A main_instance {"main"};
    object2.set_handler([&main_instance](int a, int b) {
            main_instance.fun1(a, b); // can even do extra logic here
        });

    object1.run();
    object2.run();
}

打印

name:local fun(84,126)
name:main fun1(42,42)