什么时候子类太不同而不能被继承？

Question

我有一组紧密相连的数据结构，感觉它们应该被继承。但是，它们的不同之处在于孩子有一些额外的变量。我可以通过以下方式实现：

struct A {
int a;
int b;
virtual int kind()=0;
A(int a_, int b_) : a{a_}, b{b_} {};
}

struct B: A {
int c;
int kind() {return 1;};
B(int a_, int b_, int c_) : A(a_, b_), c{c_} {};
}

struct C : A {
int d;
int kind() {return 2;};
C(int a_, int b_, int d_) : A(a_, b_), d{d_} {};
}

但是如果我想遍历这些向量并访问派生类的变量，它开始变得有点混乱：

std::vector<A*> v;
v.push_back(new B(1,1,1));
v.push_back(new C(1,1,2));

for (A* bar : v) {
    if (bar->kind() == 1) {
        auto *bar_ = dynamic_cast<B*>(A);
        std::cout << bar_->c << std::endl;
    } else if (bar->kind() == 2) {
        auto *bar_ = dynamic_cast<C*>(A);
        std::cout << bar_->d << std::endl;
    }
}

这种事情是正常的，还是我错过了什么并违反了一些重要的规则？我发现的大多数继承示例没有不同的重要成员变量或方法，只是相同的实现方式不同。

Answer 1

您已经完成了创建虚拟基类的工作。除了将类型作为值返回之外，您还可以重载要执行单独操作的函数。

struct A {
  virtual ~A() = default;
  int a;
  int b;
  virtual int get_value() const = 0;
  A(int a_, int b_) : a{a_}, b{b_} {};
}

struct B: A {
  int c;
  int get_value() const override {return c;};
  B(int a_, int b_, int c_) : A(a_, b_), c{c_} {};
}

struct C : A {
  int d;
  int get_value() const override {return d;};
  C(int a_, int b_, int d_) : A(a_, b_), d{d_} {};
}

请注意，我在这里使用了override 说明符。这在现代 c++ 中是一种很好的做法，可提高可读性和代码安全性。

现在，我们可以使用虚函数来简化主代码

std::vector<A*> v;
v.push_back(new B(1,1,1));
v.push_back(new C(1,1,2));
        
for (auto* bar : v) {
  std::cout << bar->get_value() << std::endl;
}

// ... do something else with v

// clean up the memory

for (auto *bar : v) {
  delete bar;
}

记得在基类中定义一个虚析构函数。这样可以确保当我们删除向量v 中的A* 时，继承类的析构函数也会被调用，并且不会发生内存泄漏。