将std :: function <void（Derived *）>转换为std :: function <void(Base*)>

Question

首先，我定义了两个相互继承的类。

class A { 
}; 
class B : public A { 
}; 

然后，我宣布一个使用std::function<void(A*)>功能：

void useCallback(std::function<void(A*)> myCallback);

最后，我收到的std::function不同的（但理论上兼容）从别的地方，我想打字在我的回调函数中使用：

std::function<void(B*)> thisIsAGivenFunction; 

useCallback(thisIsAGivenFunction); 

我的编译器（铛++）拒绝这个，因为类型与预期类型不匹配。但从A继承的B，thisIsAGivenFunction是可以接受的。

应该是？如果不是，为什么？如果它应该，那么我做错了什么？

Answer 1

当有人可能会传递给您随机Fruit包括Pear时，您无法通过&Foo(Apple)。

Answer 2

让我们假设你的类层次结构是有点大：

struct A { int a; }; 
struct B : A { int b; }; 
struct C : A { int c; }; 

，你拥有的功能像下面：

void takeA(A* ptr) 
{ 
    ptr->a = 1; 
} 

void takeB(B* ptr) 
{ 
    ptr->b = 2; 
} 

有了这样的，我们可以说，takeA是调用任何实例类派生自A（或A本身），并且该takeB是可调用与任何实例的cl屁股B：

takeA(new A); 
takeA(new B); 
takeA(new C); 

takeB(new B); 
// takeB(new A); // error! can't convert from A* to B* 
// takeB(new C); // error! can't convert from C* to B* 

现在，std::function是，它是一个包装可赎回对象。它不那么在意存储函数对象的签名，只要该对象是调用其std::function包装参数：

std::function<void(A*)> a; // can store anything that is callable with A* 
std::function<void(B*)> b; // can store anything that is callable with B* 

你所要做的，就是std::function<void(B*)>转换为std::function<void(A*)>。换句话说，您想要将包含B*的可调用对象存储在包装类中，其功能为A*。是否存在A*到B*的隐式转换？不，那里没有。

也就是说，一个可以作为很好的指针调用std::function<void(A*)>到C类的一个实例：

std::function<void(A*)> a = &takeA; 
a(new C); // valid! C* is forwarded to takeA, takeA is callable with C* 

如果std::function<void(A*)>可以包装调用对象的实例只B*服用，你将如何指望它与C*一起工作？：

std::function<void(B*)> b = &takeB; 
std::function<void(A*)> a = b; 
a(new C); // ooops, takeB tries to access ptr->b field, that C class doesn't have! 

幸运的是，上面的代码没有编译。

然而，这种反其道而行之的方式是罚款：

std::function<void(A*)> a = &takeA; 
std::function<void(B*)> b = a; 
b(new B); // ok, interface is narrowed to B*, but takeA is still callable with B* 

Answer 3

它的工作原理，但在相反的方向：

struct A {}; 
struct B: A {}; 

struct X {}; 
struct Y: X {}; 

static X useCallback(std::function<X(B)> callback) { 
    return callback({}); 
} 

static Y cb(A) { 
    return {}; 
} 

int main() { 
    useCallback(cb); 
} 

回调的签名声明什么将被传递给它，什么是被收回。具体的回调可以采取较少的具体类型，如果不关心他们太多。同样，它可以返回更具体的类型，额外的信息将被剥离。参考协变与逆变类型（简化措辞中的输入/输出）。