如何通过绑定另一个成员函数的参数来创建 C++ 成员函数？

Question

我在“即时”创建一个指向成员函数 (PTMF) 类型的变量时遇到问题（即，通过 std::bind 固定现有成员函数的一些参数）。我的问题是 C++11 或后 C++11 标准是否有可能。

Preambula：我有一个类，它存储从 PTMF 初始化的 std::functions 的静态 const 数组，以下称为“处理程序”。最初，它们是具有名称和实现的常规成员函数，因此我从未使用过 C++11 和 std::function。然后，我决定它们中的许多几乎相似，并决定使用“生成器函数”生成它们。我想避免使用模板来生成，因为这些几乎相似的处理程序的数量将在未来急剧增加（大约 200 多个），而模板化只会导致代码膨胀。

如果有问题的 PTMF 是静态的，那么通过 std::bind 生成处理程序不会有任何问题。一个简化的例子：

#include <iostream>
#include <functional>


using namespace std;


struct A {
    typedef function<void(int)> HandlerFn;

    static void parametrized_handler(int i, const char *param) {
        cout << "parametrized handler: " << param << endl;
    }

    static void handler(int i) { cout << "handler 1" << endl; }

    int mm;
};

static const A::HandlerFn handler2 = [](int) { cout << "handler 2" << endl; };

static const A::HandlerFn handler3 = bind(A::parametrized_handler,
                                          placeholders::_1,
                                          "test_param");


int main()
{
    A::handler(42);
    handler2(42);
    handler3(42);

    return 0;
}

输出：

$ ./a.out 
handler 1
handler 2
parametrized handler: test_param

当我转向非静态成员函数时，问题就出现了。 std::bind 无法生成像 PTMF 一样的函数对象。我知道我可以将一个真实对象作为第一个参数传递给 bind 并获得一个工作函数，但这不是我想要的：当我初始化一个静态 const 数组时，根本没有对象，并且 bind 的结果将无论如何都充当常规的非成员函数。

非静态成员函数的预期实现（带有虚构的 std::bind_mem 绑定器）：

#include <iostream>
#include <functional>


using namespace std;

struct A;


struct A {
    typedef function<void(int)> HandlerFn;

    void parametrized_handler(int i, const char *param) {
        mm;
        cout << "parametrized handler: " << param << endl;
    }

    void handler(int i) const { mm; cout << "handler 1" << endl; }

    const HandlerFn handler2 = [this](int i) { mm; cout << "handler 2" << endl; };

    int mm;
};


// An imaginary PTMF binder
// static const A::HandlerFn handler3 = bind_mem(A::parametrized_handler,
//                                               placeholders::_1,
//                                               "test_param");



int main()
{
    A a;

    (a.handler)(42);
    (a.handler2)(42);
    //(a.handler3)(42);

    return 0;
}

输出：

$ ./a.out 
handler 1
handler 2

那么有没有办法实现 PTMF 参数绑定？

Answer 1

要绑定指向非静态成员函数的指针，您需要一个对象。

#include<functional>

struct A {
    typedef std::function<void(int)> HandlerFn;
    void mem(int);
    void static static_mem(int);
};

void foo() {
    A a;
    A::HandlerFn h1 = A::static_mem;
    //This captures a by ref
    A::HandlerFn h2 = std::bind(&A::mem, std::ref(a), std::placeholders::_1);
    //This captures a by copy
    A::HandlerFn h3 = std::bind(&A::mem, a, std::placeholders::_1);
    //Change to =a for copy
    A::HandlerFn h4 = [&a](int i){
        a.mem(i);
    };
    h1(34);
    h2(42);    
}

链接：https://godbolt.org/g/Mddexq