需要覆盖逆变换解决方法

Question

我很难找到（我确信这是一种非常常见的）设计模式来解决以下问题。考虑这段代码：

class AA {};
class BB : public AA {};

class A
{
public:
    virtual void foo(AA& aa) = 0;
};

class B : A
{
public:
    void foo(BB& bb){cout<<"B::foo"<<endl;}
};

int main()
{
    B b;
    BB bb;
    b.foo(bb);
}

此代码不会编译，因为 B 类没有覆盖纯虚函数 'foo'。编译器将 B 声明的 foo 仅视为对 foo 的重载，因为在覆盖函数的输入参数中不允许协变。

现在，我明白了其中的原因。 B 继承自 A 的事实意味着它应该能够处理任何带有 AA 类型参数的 foo 调用，而前面的代码没有给出处理除 BB 之外的任何参数类型的实现。

当然，我可以在 B 的 foo 实现中将 aa 强制转换为 BB，但我正在寻找一种保留类型安全性并实际上强制 B 类的实现者也按顺序实现从 AA 继承的类的解决方案用于编译代码。在一个理想的世界里，我可以写出类似这样的伪代码：

class A
{
public:
    abstract class AA{}; //indicates that any child of A must implement also child of AA
    abstract void foo(AA& aa);
};

class B : public A
{
public:
    class BB : AA{}; //will not compile without this
    void foo(BB& bb){cout<<"B::foo"<<endl;}
};

有没有办法在 C++ 中实现类似的功能？ （可能通过某种映射对象而不需要继承来提升）

请注意，实际上（与示例不同），BB 和 AA 之间的继承至关重要，因为 AA 有许多共享许多品质的孩子，最后我想要完成的是迭代 A 类的向量并仅使用适当的参数（AA 向量）运行“foo”

Answer 1

为了提供类型安全，您应该使用模板而不是继承。

class AA {};
class BB : AA {};

template <typename Managed> class FooManager {
    virtual void foo(Managed& m) { /* default implementation */ }
};

class B : public FooManager<BB> {
    void foo(BB bb) { cout << "B:foo()" << endl; }
};

后面的代码，比如要遍历一个数组，

template<typename Managed> void processAll(vector<Managed> v, FooManager<Managed> mgr) {
    for(Managed& m : v) mgr.foo(m);
}

B b;
vector<BB> bbs;
processAll(bbs, b);

编辑：错字修复

Answer 2

您可以查看访问者模式。这是“双重调度”类型问题的一般解决方案（基于对象和消息调度到虚函数）。

即把foo()放入一个访问者，将A::foo()重命名为A::Visit(FooVisitor& )：

编辑：澄清一下，这可能有助于解开层次结构的目的。如果您考虑一下，您正在尝试根据另一个（A 和B）来建模一个层次结构（AA 和BB）的关系。这对于建模，甚至从概念上考虑都非常尴尬。

要将其重新建模为访问者，您通常会将其中一个层次结构转换为单个类，而是对您可以通过访问者在算法层次结构中对该类执行的操作进行建模.这更加健壮，因为它强制您显式地实现层次关系的每个组合，并且如果您稍后修改层次结构，它将在编译时中断（很好）。

class A; class B;
struct AVisitor 
{ 
    virtual ~AVisitor() { } 

    virtual void Visit(A& ) = 0;
    virtual void Visit(B& ) = 0;
};

class A
{
public:
    virtual ~A() { }

    virtual void Visit(AVisitor & visitor) { visitor.Visit(*this); }
};

class B : public A
{
public:
    virtual void Visit(AVisitor & visitor) { visitor.Visit(*this); }
};

struct PrintingVisitor : public AVisitor
{
    void Visit(A& a){cout<<"A::foo"<<endl;}
    void Visit(B& b){cout<<"B::foo"<<endl;}
};

int main()
{
    B b;
    PrintingVisitor printer;
    b.Visit(printer);
}