重写一系列子类的方法

Question

给定遗留代码，系统具有以下类层次结构：

          Base
          ^
          |
----------+---------------
^      ^     ^     ^     ^ 
|      |     |     |     |
A1     B1    C1    D1    E1
^      ^     ^     ^     ^ 
|      |     |     |     |
A2     B2    C2    D2    E2
.......
^      ^     ^     ^     ^ 
|      |     |     |     |
An     Bn    Cn    Dn    En

该层次结构表示某个特定域中的消息。

Base 类当然是所有消息的基类。 A1..E1 是属于域版本 1 的消息，A2..E2 是属于版本 2 的消息，依此类推。请注意，An 必须直接继承自 An-1，因为 An 会覆盖 An-1 的特定方法。

有一些功能对于所有消息都是通用的，因此它被定义为Base::PerformFunctionality。部分功能仅特定于版本n，因此存在虚函数Base::SpecificPartOfFunctionality，由Base::PerformFunctionality调用。

所以我的问题是如何通过所有 An..En 覆盖 Base::SpecificPartOfFunctionality。

我看到了 2 种可能的解决方案，但我不太喜欢：

1. 在每个 An..En 中实现 Base::SpecificPartOfFunctionality。

   这个解决方案的问题是每个类的实现应该完全相同，所以我只是重复代码。

   另一个问题是，如果引入新类 Fn，开发人员可能会忘记实现SpecificPartOfFunctionality。

2. 引入从 Base 派生的 BaseN 类，同时每个 An..En 也从 BaseN 派生：

   类 BaseN : public Base {
      //...
      具体部分功能（）{...}
   };
   
   An 类：公共 An-1，公共 BaseN { .. }
   

   此解决方案的问题在于它引入了钻石问题。

   另一个问题是，如果其他版本m也需要覆盖Base::SpecificPartOfFunctionality，将会发生什么情况。在解决方案之后，我们将引入BaseM，它将覆盖Base::SpecificPartOfFunctionality。因此，将为BaseN 或BaseN 的An 调用哪个SpecificPartOfFunctionality。一团糟。

有什么建议吗？

Answer 1

struct Base {
  virtual void PerformFunctionality() {
    stuff();
    SpecificPartOfFunctionality();
    more_stuff();
  }
private:
  virtual void SpecificPartOfFunctionality() {}
};

template<class Prev>
struct Version3 : Prev {
protected:  // Not private if v4's override might need to call this.
  virtual void SpecificPartOfFunctionality() {
    v3_specific_stuff();
  }
};

struct A1 : Base {};
struct A2 : A1 {};
struct A3 : Version3<A2> {};

struct B1 : Base {};
struct B2 : B1 {};
struct B3 : Version3<B2> {};

唯一的缺点是您无法轻松地在当前 C++ 中转发构造函数，并且为了简单起见，可能始终使用 A2 和 B2 的默认构造函数。

然而，在 C++0x 中，您可以转发构造函数：

template<class Prev>
struct Version3 : Prev {
  using Prev::Prev;
  //...
};

struct C2 : C1 {
  C2(int);  // No default constructor.
};
struct C3 : Version3<C2> {
  C3() : Version3<C2>(42) {}
};

---

请注意，An 必须直接继承自 An-1，因为 An 会覆盖 An-1 的特定方法。

你误解了一些东西。 An 不需要直接从 An-1 继承。例如，这很好用：

struct Example {
  virtual void f();
};

template<class B>
struct Intermediate : B {};

struct Concrete : Intermediate<Example> {
  virtual void f();  // Overrides Example::f.
};

请记住，如果这不起作用，那么您的 An 首先无法从您的基类重写 SpecificPartOfFunctionality！在您的任何示例中， An 都不直接从 Base 继承。

Answer 2

在全局范围内定义一个实现该功能的友元函数，并且让 SpecificPartsOfFunctionality 除了调用它之外什么也不做。例如，

void FunctionalityN(Base* b)
{
    b->DoThings();
    ...
}

class An : public Base
{
    friend void FunctionalityN();
    virtual void SpecificPartOfFunctionality() { FunctionalityN(this); }
    ....
};

严格来说，FunctionalityN 甚至不必是朋友，尽管它会让事情变得更容易。这使得扩展到 Fn、Gn 等变得简单，随后用 NewFunctionalityN 替换 FunctionalityN 也非常容易。