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

What is the correct way to implement derived classes with arbitrary combinations of common virtual function implementations?

本文关键字：实现 是什么 方法 派生 组合 虚拟 常见 函数 任意      更新时间：2023-10-16

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

我知道钻石继承的方法，但我怀疑还有更好的方法。

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 */ }
};

使用默认实现的中间类：

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 */ }
};

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

这里有一种钻石继承的方法。

#include <iostream>
using namespace std;
struct base {
virtual void f() { cout << "f_0n"; /* implementation f_0 */ }
virtual void g() { cout << "g_0n"; /* implementation g_0 */ }
virtual void h() { cout << "h_0n"; /* implementation h_0 */ }
};
struct f_1 : public virtual base {
void f() override { cout << "f_1n"; /* implementation f_1 */ }
};
struct g_1 : public virtual base {
void g() override { cout << "g_1n"; /* implementation g_1 */ }
};
struct h_1 : public virtual base {
void h() override { cout << "h_1n"; /* implementation h_1 */ }
};
struct h_2 : public virtual base {
void h() override { cout << "h_2n"; /* 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 << "nWn";
W w;
w.f();
w.g();
w.h();
cout << "nXn";
X x;
x.f();
x.g();
x.h();
cout << "nYn";
Y y;
y.f();
y.g();
y.h();
cout << "nZn";
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
相关文章：