c++ - std::bind 如何与成员函数一起工作

Question

我正在与 std::bind 一起工作但是当我们将它与成员类函数一起使用时，我仍然不明白它是如何工作的。

如果我们有以下函数:

double my_divide (double x, double y) {return x/y;}

我完全理解接下来的代码行:

auto fn_half = std::bind (my_divide,_1,2);               // returns x/2

std::cout << fn_half(10) << '\n';                        // 5

但是现在，使用以下代码绑定(bind)到成员函数时，我有一些问题。

struct Foo {
    void print_sum(int n1, int n2)
    {
        std::cout << n1+n2 << '\n';
    }
    int data = 10;
};

Foo foo;

auto f = std::bind(&Foo::print_sum, &foo, 95, _1);
f(5);

为什么第一个参数是引用？我想得到一个理论上的解释。

第二个参数是对对象的引用，对我来说这是最难理解的部分。我想是因为std::bind需要上下文，对吗？总是这样吗？有 std::bind当第一个参数是成员函数时需要引用的某种实现？

Answer 1

当你说“第一个参数是一个引用”时，你肯定是说“第一个参数是一个指针”:&运算符获取对象的地址，产生一个指针。

在回答这个问题之前，让我们简单地退后一步，看看你第一次使用 std::bind()当你使用

std::bind(my_divide, 2, 2)

你提供一个函数。当一个函数被传递到任何地方时，它会衰减为一个指针。上面的表达式等价于这个，显式取地址

std::bind(&my_divide, 2, 2)

std::bind() 的第一个参数是一个标识如何调用函数的对象。在上面的例子中，它是一个指向函数的指针，类型为 double(*)(double, double) .任何其他具有合适的函数调用运算符的可调用对象也可以。

由于成员函数很常见，std::bind()提供处理指向成员函数的指针的支持。当您使用 &print_sum你只是得到一个指向成员函数的指针，即类型为 void (Foo::*)(int, int) 的实体.虽然函数名称隐式衰减为指向函数的指针，即 &可以省略，成员函数(或数据成员，就此而言)并非如此:要获得指向成员函数的指针，必须使用 & .

请注意，指向成员的指针特定于 class但它可以与该类的任何对象一起使用。也就是说，它独立于任何特定对象。 C++ 没有直接的方法来获取直接绑定(bind)到对象的成员函数(我认为在 C# 中，您可以通过使用具有应用成员名称的对象来获取直接绑定(bind)到对象的函数；但是，距今已有 10 多年了我上次编写了一些 C#)。

内部，std::bind()检测到成员函数的指针被传递，并且很可能将其转换为可调用对象，例如，通过使用 std::mem_fn()用它的第一个参数。由于非static成员函数需要一个对象，解析可调用对象的第一个参数是指向适当类的对象的引用或[智能]指针。

要使用指向成员函数的指针，需要一个对象。当使用指向成员的指针时 std::bind() std::bind() 的第二个参数相应地需要指定对象何时来自。在你的例子中

std::bind(&Foo::print_sum, &foo, 95, _1)

生成的可调用对象使用 &foo ，即指向 foo 的指针(类型 Foo* )作为对象。 std::bind()当第一个参数是指向成员的指针时，足够聪明地使用任何看起来像指针的东西，任何可以转换为适当类型的引用(如 std::reference_wrapper<Foo> )或对象的[拷贝]作为对象的对象。

我怀疑，您从未见过指向成员的指针 - 否则就很清楚了。这是一个简单的例子:

#include <iostream>

struct Foo {
    int value;
    void f() { std::cout << "f(" << this->value << ")\n"; }
    void g() { std::cout << "g(" << this->value << ")\n"; }
};

void apply(Foo* foo1, Foo* foo2, void (Foo::*fun)()) {
    (foo1->*fun)();  // call fun on the object foo1
    (foo2->*fun)();  // call fun on the object foo2
}

int main() {
    Foo foo1{1};
    Foo foo2{2};

    apply(&foo1, &foo2, &Foo::f);
    apply(&foo1, &foo2, &Foo::g);
}

函数apply()简单地得到两个指向 Foo 的指针对象和指向成员函数的指针。它调用每个对象指向的成员函数。这个搞笑->*运算符将指向成员的指针应用于指向对象的指针。还有一个.*运算符将指向成员的指针应用于对象(或者，因为它们的行为就像对象一样，对对象的引用)。由于指向成员函数的指针需要一个对象，因此有必要使用这个请求对象的操作符。内部，std::bind()安排同样的事情发生。

当apply()用两个指针和 &Foo::f 调用它的行为与成员 f() 完全相同将在相应的对象上调用。同样在调用 apply() 时用两个指针和 &Foo::g它的行为与成员 g() 完全相同将在各自的对象上调用(语义行为是相同的，但编译器可能会更难内联函数，并且在涉及成员指针时通常会失败)。