Boost::Bind和虚函数重载:它们为什么工作?

Boost::Bind and virtual function overloads: why do they work?

本文关键字：为什么 工作 函数 Bind Boost 重载      更新时间：2023-10-16

我写了一些代码，害怕它不会工作-所以我写了一个原型:

#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <iostream>
class base {
private:
    boost::function<void (int)> action;
protected:
    virtual void onDataBaseReady(int i) { std::cout << i << std::endl; }
public:
    void call() {
        action(10);
    }
    base() {
        action = boost::bind(&base::onDataBaseReady, this, _1);
    }
};
class child : public base {
protected:
    virtual void onDataBaseReady(int i) { std::cout << i+10 << std::endl; }
};
int main()
{
    static child c;
    c.call();
    std::cin.get();
    return 0;
}

编译并工作。(输出20)。但是为什么呢?我也在VS2010下测试，想知道它是否可以跨平台工作(说在GCC下编译)?

主要是action = boost::bind(&base::onDataBaseReady, this, _1);让我害怕-我们说&base::…

指向virtual方法的指针在调用virtual函数时进行查找。

#include <iostream>
#include <memory>
struct base {
  virtual void foo() { std::cout << "basen"; }
  virtual ~base() {}
};
struct derived:base {
  void foo() override final { std::cout << "derivedn"; }
};
int main() {
  void (base::*mem_ptr)() = &base::foo;
  std::unique_ptr<base> d( new derived() );
  base* b = d.get();
  (b->*mem_ptr)();
}

所以，它"只是工作"。成员函数指针(this->*&base::foo)()与完全限定函数调用this->base::foo()不同。第一种方法是存储调用this->foo()的foo部分，第二种方法是跳过virtual方法查找并直接调用base::foo。

main action = boost::bind(&base::onDataBaseReady, this， _1);让我害怕-我们说&base::…

如果它执行静态分派，而不是动态分派，实际上会更可怕。考虑这个简单的例子:

struct base {
   virtual void foo() { /* maintain some invariants */ }
};
struct derived : base {
   virtual void foo() { /* maintain different invariants */ }
};

然后考虑在父对象上绑定函数并在派生对象上调用它。derived的实现者知道哪些不变量适用于派生类型，这些不变量可能与基类型中的不变量相同，可能是子集，也可能完全不同。

void apply(base & b) {
   std::bind(&base::foo, &b)();
}

如果在绑定时解决了分派问题，并且将函子应用于派生类型(您可能不知道派生类型的确切类型!)，则派生类型的不变量可能会被破坏。在apply函数的上下文中，不可能知道对象到底是什么，或者该类型的不变量是什么，因此您可能想要做的是让动态分派发挥它的魔力。

[这是从高级设计的角度来看，甚至不深入细节，你不能使用指向成员的指针来执行静态分派…]

相关文章：