在 C++ 中绑定派生类方法从分离的 std::function 变量调用，在实例范围之外

Question

Consider having a base class that is inherited by multiple sub-classes.

Is it possible to bind some of its methods to create function that can be called directly and not from the inherited class instance.

The following example should emphasis the case :

class A {
    virtual void method(int a, int b) { ... } 
};

class B : public A {
    virtual void method(int a, int b) { ... }
};
class C : public A {
    virtual void method(int a, int b) { ... }
};


void main () {

    A * a = new B();
    A * aa= new C();

    std::function<void(int,int)> f1 = std::bind(&A::method, &a);
    std::function<void(int,int)> f2 = std::bind(&A::method, &aa);

    f(1,2); 
    f(2,3); 
    ...
}

however, it doesn't compile due to the following error :

No viable conversion from '__bind<void (A::*)(int, int), A **>' to 'std::function<void (int, int)>'

Perhaps anybody can help me fix it ?

Answer 1

You need to use placeholders for your arguments. I would also remove the reference from the second argument as you've a pointer already and passing a reference to a pointer would pass in the address of pointer which is not what you want.

std::function<void(int,int)> f1 = std::bind(&A::method, a, std::placeholders::_1, std::placeholders::_2);

Hope this helps.

Answer 2

There are a few issues with your code.

• You need to make the methods public
• void main() comes from a time of pre-standardization, it's not valid C++ code. You need int main()
• don't use raw pointers that have ownership. use smart pointers.
• don't use std::bind . Use lambdas. They are superior in every way.

---

In order to not overload you with all the changes, lets do this with lambdas and keep the raw pointers:

int main ()
{
    A * a = new B();
    A * aa= new C();

    std::function<void(int,int)> f1 = [=](int p1, int p2) { return a->method(p1, p2); };
    std::function<void(int,int)> f2 = [=](int p1, int p2) { return aa->method(p1, p2); };

    f1(1, 2);
    f2(2, 3);
}

And now a variant with smart pointers. If your f1 and f2 don't live beyond a and aa you can do this:

void test()
{
    std::unique_ptr<A> a = std::make_unique<B>();
    std::unique_ptr<A> aa = std::make_unique<C>();

    std::function<void(int,int)> f1 = [ptr = a.get()](int p1, int p2) { return ptr->method(p1, p2); };
    std::function<void(int,int)> f2 = [ptr = aa.get()](int p1, int p2) { return ptr->method(p1, p2); };

    f1(1, 2);
    f2(2, 3);
}

Else you need to use shared_ptr :

void test_shared()
{
    std::shared_ptr<A> a = std::make_shared<B>();
    std::shared_ptr<A> aa = std::make_shared<C>();

    std::function<void(int,int)> f1 = [=](int p1, int p2) { return a->method(p1, p2); };
    std::function<void(int,int)> f2 = [=](int p1, int p2) { return aa->method(p1, p2); };

    f1(1, 2);
    f2(2, 3);
}

Also if you don't need the type erasure of std::function you should make f1 and f2 lambdas. Eg auto f1 = [=] ...