类设计复杂性 (C++)

Question

我的课是

• Base
  • Derived_A
  • Derived_B
• Parent
  • Child_One
  • Child_Two

Base 有两个签名函数：

virtual void foo( const Parent& ) = 0;
virtual void bar( const Base& ) = 0;

，程序的其他部分所期望的。

问题是：

Derived_A 对待 Child_One 和 Child_Two 相同。但是Derived_B 对待它们的方式不同。

我应该如何实现这个？

一种方法是找出传递给Derived_B.foo 的对象类型。这显然是“设计缺陷”。 我尝试的另一种方法是将签名函数更改为：

class Base
{
  class Derived_A;
  class Derived_B;

//  virtual void bar( const Base& ) = 0;
  virtual void bar( const Derived_A& ) = 0;
  virtual void bar( const Derived_B& ) = 0;
}

class Derived_A: public virtual Base
{ 

  virtual void foo( const Parent& ) = 0;
}

class Derived_B: public virtual Base
{ 
  virtual void foo( const Child_A& ) = 0;
  virtual void foo( const Child_B& ) = 0;
}

但是现在bar 函数不能使用Base.foo。所以我要写两次bar函数，虽然代码完全一样。

还有其他方法可以解决这个问题吗？你推荐哪一个？

附：我想不出一个好的标题。请随意修改。

Answer 1

您描述的问题称为Double Dispatch。该链接描述了问题和一些可能的解决方案（包括多态函数签名和访问者模式）。

Answer 2

如果没有详细说明这两种类型层次结构之间的关系以及它们之间的交互方式，就不可能说哪种方法是合适的。我已经对其他答案和另一个可行的替代方案进行了概述，该替代方案可以扩展到评论中提到的访问者模式。

在实现virtual 中的virtual 函数的孩子中执行多态行为，正如乔伊安德烈斯已经建议的那样，一般来说，这是一个非常典型的面向对象的解决方案。是否合适，取决于对象的职责。

Olayinka 建议并在您的问题中已经提到的类型检测肯定闻起来很笨拙，但根据细节，可能是 N 邪恶中的最小值。它可以通过返回 enum 的成员函数（我猜这就是 Olayinka 的答案试图表示的）或一系列 dynamic_casts 来实现，如question you linked 中的一个答案所示。

一个简单的解决方案可能是在Base 中重载foo：

struct Base {
    virtual void foo(const Parent&) = 0;
    virtual void foo(const Child_Two&) = 0;
};
struct Derived_A: Base { 
    void foo(const Parent& p) {
        // treat same
    }
    void foo(const Child_Two& p) {
        foo(static_cast<Parent&>(p));
    }
};
struct Derived_A: Base { 
    void foo(const Parent& p) {
        // treat Child_One (and other)
    }
    void foo(const Child_Two& p) {
        // treat Child_Two
    }
};

如果Base的其他子类型对Child_One和Child_Two处理相同，那么foo(const Child_Two&)的实现可以放在Base中以避免重复。

这种方法的问题是foo 必须使用正确的静态类型的引用来调用。调用不会根据动态类型解析。这对您的设计可能更好或更糟。如果您需要多态行为，您可以使用访问者模式，该模式本质上是在上述解决方案之上添加虚拟调度：

struct Base {
    foo(Parent& p) {
        p.accept(*this);
    }
    virtual void visit(Child_A&) = 0;
    virtual void visit(Child_B&) = 0;
};

struct Parent {
    virtual void accept(Base&) = 0;
};

struct Child_A: Parent {
    void accept(Base& v) {
        v.visit(*this);
    }
};
// Child_B similarly

struct Derived_A: Base { 
    void treat_same(Parent&) {
        // ...
    }
    void visit(Child_A& a) {
        treat_same(a);
    }
    void visit(Child_B& b) {
        treat_same(b);
    }
};
struct Derived_B: Base { 
    void visit(Child_A&) {
        // ...
    }
    void visit(Child_B&) {
        // ...
    }
};

还有一些样板，但由于您似乎非常不愿意在孩子身上实施这种行为，所以这对您来说可能是个好方法。

Answer 3

您可以轻松地在 Parent 中创建 virtual foo 方法。既然您希望 Derive_A 对所有 Parent 的子类一视同仁，为什么不在 Parent 中实现一个类。这是最合乎逻辑的事情，因为很有可能，如果你想对他们两个都做同样的事情，那么他们两个必须有相似的数据，这些数据都存在于 Parent 中。

class Parent{
   virtual void treatSame(){
       // Some operations that treat both Child_A, and Child_B
       // the same thing to both Child_A and Child_B.
   }
   virtual void foo() = 0;
}

由于您希望 Derived_B 在 Child_A 和 Child_B 中执行不同的操作，因此请利用多态性。考虑下面的其余类：

class Child_A : public Parent{
    virtual void foo(){
        // Foo that is designed for special Child_A.
    }
}

class Child_B : public Parent{
    virtual void foo(){
        // Foo that is designed for special Child_B.
    }
}


class Base{
     virtual void foo(Parent) = 0;
     virtual void bar(Base) = 0;
}

class Derived_A: public Base
{ 
  virtual void foo( Parent& p){
     p.treatSame();
  }
}

class Derived_B: public Base
{ 
  virtual void foo( Parent& p){
      p.foo();  // Calls appropriate function, thanks to polymorphism.
  }
}

可能的用法如下：

int main(){
    Child_A a;
    Child_B b;

    Derived_A da;
    da.foo(a);  // Calls a.treatSame();
    da.foo(b);  // Calls a.treatSame();

    Derived_B db;
    db.foo(a);  // Calls a.foo();
    db.foo(b);  // Calls b.foo();
}

请注意，这仅在参数是指针或引用时才有效（我更喜欢尽可能处理引用）。否则虚拟调度（选择适当的功能）将无法正常工作。

Answer 4

我不确定语法，但你明白了要点。

class Base{
  virtual void bar( Base ) = 0;
  virtual void foo( Parent ) = 0;
}

class Derived_A: public virtual Base{ 
  virtual void foo( Parent ) = 0;
}

class Derived_B: public virtual Base{ 
  virtual void foo( Parent ){
      //switch case also works
      return parent.get_type() == Parent::TYPE_A ? foo_A((Child_A)parent) : foo_B((Child_B)parent);
  }
  virtual void foo_A( Child_A ) = 0;
  virtual void foo_B( Child_B ) = 0;
}

class Parent{
  virtual int get_type() = 0;
}

class Child_A: public virtual Parent{ 
     return Parent::TYPE_A;
}

class Child_B: public virtual Parent{ 
     return Parent::TYPE_B;
}