Question

用通用成员函数实现的不同组合来实现一组派生类而不复制代码的正确方法是什么？类W，X，Y和Z都从类base派生，因为它们需要能够访问基类中的成员变量。 / p>

我知道可以通过钻石继承来做到这一点，但我怀疑还有更好的方法。

class base {
      virtual void f() { /* implementation f_0 */ }
      virtual void g() { /* implementation g_0 */ }
      virtual void h() { /* implementation h_0 */ }
  };

 class W : public base {
      void g() override { /* implementation g_1 */ }
  };

  class X : public base {
      void g() override { /* implementation g_1 */ }
      void h() override { /* implementation h_1 */ }
  };

  class Y : public base {
      void f() override { /* implementation f_1 */ }
      void h() override { /* implementation h_1 */ }
  };

  class Z : public base {
      void f() override { /* implementation f_1 */ }
      void h() override { /* implementation h_2 */ }
  };

Answer 1

使用默认实现的中间类：

class base {
public:
    virtual ~base() = default;
    virtual void f() = 0;
    virtual void g() = 0;
    virtual void h() = 0;
};

class derived : public base {
    void f() override { /* implementation f_0 */ }
    void g() override { /* implementation g_0 */ }
    void h() override { /* implementation h_0 */ }
};


class X : public derived {
    void g() override { /* implementation g_1 */ }
};

class Y : public derived {
    void f() override { /* implementation f_1 */ }
};

class Z : public derived {
    void h() override { /* implementation h_1 */ }
};

Answer 2

Marc Gregoire在Professional C++的第10章中讨论了这个主题。

这是钻石继承的一种方法。

  #include <iostream>
  using namespace std;

  struct base {
      virtual void f() { cout << "f_0\n"; /* implementation f_0 */ }
      virtual void g() { cout << "g_0\n"; /* implementation g_0 */ }
      virtual void h() { cout << "h_0\n"; /* implementation h_0 */ }
  };

  struct f_1 : public virtual base {
      void f() override { cout << "f_1\n"; /* implementation f_1 */ }
  };

  struct g_1 : public virtual base {
      void g() override { cout << "g_1\n"; /* implementation g_1 */ }
  };

  struct h_1 : public virtual base {
      void h() override { cout << "h_1\n"; /* implementation h_1 */ }
  };

  struct h_2 : public virtual base {
      void h() override { cout << "h_2\n"; /* implementation h_2 */ }
  };


  struct W : public g_1  {
      // void g() override { /* implementation g_1 */ }
  };

  struct X : public g_1, h_1 {
      // void g() override { /* implementation g_1 */ }
      // void h() override { /* implementation h_1 */ }
  };

  struct Y : public f_1, h_1 {
      // void f() override { /* implementation f_1 */ }
      // void h() override { /* implementation h_1 */ }
  };

  struct Z : public f_1, h_2 {
      // void f() override { /* implementation f_1 */ }
      // void h() override { /* implementation h_2 */ }
  };

  int main() {

      cout << "\nW\n";
      W w;
      w.f();
      w.g();
      w.h();

      cout << "\nX\n";
      X x;
      x.f();
      x.g();
      x.h();

      cout << "\nY\n";
      Y y;
      y.f();
      y.g();
      y.h();

      cout << "\nZ\n";
      Z z;
      z.f();
      z.g();
      z.h();
  }

输出：

W
f_0
g_1
h_0

X
f_0
g_1
h_1

Y
f_1
g_0
h_1

Z
f_1
g_0
h_2

用常见虚函数实现的任意组合来实现派生类的正确方法是什么？

2 个答案: