将 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);

我的编译器 (clang++) 拒绝这样做，因为 thisIsAGivenFunction 的类型与预期的类型不匹配。但是由于B 继承自A，所以thisIsAGivenFunction 是可以接受的。

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

Answer 1

假设您的类层次结构更大一点：

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 是可调用的 与 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* 的隐式转换？不，没有。

也就是说，也可以使用指向类C 实例的指针调用std::function<void(A*)>：

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 2

当有人可能给你一个随机的Fruit 包括Pear 时，你不能传递&Foo(Apple)。

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);
}

回调的签名声明了将传递给它的内容以及要返回的内容。如果不太关心它们，特定的回调可以采用较少的特定类型。同样它可以返回更具体的类型，额外的信息将被剥离。请参阅协变与逆变类型（简化措辞的输入/输出）。