c++ - 多个 "level"派生抽象类

Question

我在 C++ 中遇到问题

• 一个具有公共(public)成员和纯虚函数的抽象基类。这是下面代码中的A。
• 具有不同成员和函数的多个派生类。这是下面代码中的B和C。
• 实现虚函数且没有新成员的多个派生类。这是下面代码中的 do_stuff_1 和 do_stuff_2。

到目前为止，我的解决方案是混合使用模板和抽象类。目标是持有指向抽象类 B 或 C 的指针并调用 do_stuff。我的问题是

1. 我的解决方案好吗？
2. 如果没有，是否有更好的解决方案？
3. 如果是这样，我应该注意哪些陷阱？

这是我目前的解决方案

#include <iostream>
#include <memory>

/* base virtual class */
class A {
public:
  int a;

  A(int a) : a(a) {}

  virtual void do_stuff() = 0;
};

/* concrete implementations of do_stuf */
template<class T>
class do_stuff_1 : public T {
public:
  using T::T;

  void do_stuff(){
    std::cout << "do_stuff_1 " << this->a << std::endl;
  }
};

template<class T>
class do_stuff_2 : public T {
public:
  using T::T;

  void do_stuff(){
    std::cout << "do_stuff_2 " << this->a + 1 << std::endl;
  }
};

/* derived classes from A */
class B : public A {
public:
  int b;         // one member here but many more in my application

  B(int a, int b): A(a), b(b) {}
};

class C : public A {
public:
  std::string c; // one member here but many more in my application

  C(int a, std::string c): A(a), c(c) {}
};

int main() {
  std::unique_ptr<B> x;
  x.reset(new do_stuff_1<B>(1, 1));
  x->do_stuff();
  std::cout << x->b << std::endl;
  x.reset(new do_stuff_2<B>(1, 2));
  x->do_stuff();
  std::cout << x->b << std::endl;

  std::unique_ptr<C> z;
  z.reset(new do_stuff_1<C>(1, "Yo"));
  z->do_stuff();
  std::cout << z->c << std::endl;
  z.reset(new do_stuff_2<C>(1, "Hello"));
  z->do_stuff();
  std::cout << z->c << std::endl;

  return 0;
}

结果是

do_stuff_1 1                                                                                                                                     
1                                                                                                                                                
do_stuff_2 2                                                                                                                                     
2                                                                                                                                                
do_stuff_1 1                                                                                                                                     
Yo                                                                                                                                               
do_stuff_2 2                                                                                                                                     
Hello 

Answer 1

您的解决方案似乎不错。这是一种编译时方法，您创建了 4 个不同的对象。

主要缺点是:

• 除非实例化模板，否则您不会知道 do_stuff() 代码是否正确。
• 您可以使用不属于基类 A 的类实例化 do_stuff_1 或 do_stuff_2。您至少应该在模​​板中使用 override 来确保它覆盖了一个虚函数。

这里有一个小的改进来解决这些问题:

template<class T>
class do_stuff_2 : public T {
public:
  using T::T;

  void do_stuff() override {
    static_assert (std::is_base_of<A, T>::value, "T should be derived from A");
    std::cout << "do_stuff_2 " << this->a + 1 << std::endl;
  }
};

顺便说一下，使用make_unique 会很好。