std :: bind会舍弃C ++ 11中参数的类型信息吗?

出现问题的地方

请考虑以下c ++代码:

Please consider the following c++ code:

#include <functional>
#include <iostream>
#include <string>

// Superclass
class A {
    public:
    virtual std::string get() const {
        return "A";
    }
};

// Subclass
class B : public A {
    public:
    virtual std::string get() const {
        return "B";
    }
};

// Simple function that prints the object type
void print(const A &instance) {
    std::cout << "It's " << instance.get() << std::endl;
}

// Class that holds a reference to an instance of A
class State {
    A &instance;
    public:
    State(A &instance) : instance(instance) { }
    void run() {

        // Invokes print on the instance directly
        print(instance);

        // Creates a new function by binding the instance
        // to the first parameter of the print function, 
        // then calls the function. 
        auto func = std::bind(&print, instance);    
        func();
    }    
};

int main() {
    B instance;
    State state(instance);

    state.run();
}

在此示例中，我们有两个类A和B. B继承自类A.这两个类都实现了一个简单的虚拟方法，该方法返回类型名称.

In this example, we have two classes A and B. B inherits from class A. Both classes implement a simple virtual method that returns the type name.

还有一个简单的方法print，它接受对A实例的引用并打印类型.

There is also a simple method, print, that accepts a reference to an instance of A and prints the type.

类State保存对A实例的引用.该类还有一个简单的方法，可以通过两种不同的方式调用print.

The class State holds a reference to an instance of A. The class also has a simple method that calls print by two different means.

奇怪的地方

处于状态的唯一方法首先直接调用print.因为我们在main方法中提供了B int的实例，所以输出如预期的那样是It's B.

The sole method in state first calls print directly. Since we supply an instance of B int the main method, the output is It's B, as expected.

但是，对于第二个调用，我们使用std::bind将实例绑定到print的第一个参数.然后，我们调用没有任何参数的结果函数.

For the second call, however, we bind the instance to the first parameter of print using std::bind. Then we call the resulting function without any arguments.

但是，在这种情况下，输出为It's A.我应该像以前一样期望输出It's B，因为它仍然是相同的实例.

In this case, however, the output is It's A. I would have expected the output It's B, as before, since it is still the same instance.

如果我将参数声明为指针而不是引用，则std::bind会按预期工作.我还将一些日志记录到两个类的构造函数中，以验证是否没有意外创建实例.

If I declare the parameters as pointers instead of references, std::bind works as expected. I also placed some logging into the constructors of both classes to verify that no instances are created accidentally.

为什么会这样?在这种情况下，std::bind是否会丢弃某些类型信息?据我了解，这一定不会发生，因为方法调用应通过运行时的vtable查找进行管理.

Why does this happen? Does std::bind discard some type information in this case? To my understanding, this must not happen since the method invocation should be managed by a vtable lookup via runtime.