C++层次类继承设计

Question

假设我有以下应用逻辑：

class classA
{
    classA(ConfigA config)
};

class classB
{
     classB(ConfigB config)
};

class App
{
    void initial(Config config){
        if( cond1)
            new classA(config.getConfigA());
        if( cond2)
            new classB(config.getConfigB());
     }
};

有没有好的模式来设计 Config 结构？目前我正在做的是

struct BConfig
{
     int a;
     int b;
};

struct ConfigA:public BConfig
{
     int c;
};
struct ConfigB:public BConfig
{
     int d;
};
struct Config
{
    ConfigA getConfigA();
    ConfigB getConfigB();
    int a;
    int b;
    int c;
    int d;
};

我想有更好的方法来做到这一点。有什么建议吗？

Answer 1

这听起来像是一个 XY 问题。您有一个正在尝试使用的特定解决方案，它可能是也可能不是您最初问题的答案。此外，您在示例中对 new 的使用不完整，不清楚何时或如何释放 Class 对象。

也就是说，考虑使用界面模式 - 类似这样的东西（仍然需要工作，但这是一个开始）：

struct IConfig {
  // TODO: identification as to which class instance this is.
  // and/or virtual methods
  int a;
  int b;
  virtual ~IConfig(){}
};

struct ConfigA : public IConfig {
  int c;
  virtual ~ConfigA(){}
};

struct ConfigB : public IConfig {
  int d;
  virtual ~ConfigB(){}
};

class IClass {
  // TODO: identification as to which class instance this is.
  // and/or virtual methods
  virtual ~IClass(){}
};

class ClassA : public IClass {
  public:
    ClassA(const IConfig & iconf) {
      ConfigA & aconf = dynamic_cast<ConfigA&>(iconf);
    }
  virtual ~ClassA(){}
};

class ClassB : public IClass {
  public:
    ClassB(const IConfig & iconf) {
      ConfigB & bconf = dynamic_cast<ConfigB&>(iconf);
    }
  virtual ~ClassB(){}
};

class App {
    IConfig * config; // in case
    IClass * cls;
    void initial(IConfig config){
      if( cond1 )
        cls = new ClassA( config );
      else if( cond2 )
        cls = new ClassB( config );
      else
        // ...
    }
};

只需确保cond1 将是真的这样的解决方案 IIF 传递给initial 的IConfig 的类型是ConfigA 以匹配正在创建的类。您可以添加更多检查以确保界面本身就是这种情况。返回常量的虚拟方法应该足够好，但它实际上取决于您在执行此操作时要达到的目标，因为这似乎已经是一种混乱的方法了。

例如，也许IConfig 的本地配置可用于确定两者 - 加载哪个类，进而确定应使用哪个 Config 类等。

事后考虑——在这种情况下，您可能希望让每个Class 都有自己的IConfig 实现，这让App（使用IConfig 数据）确定要创建哪个类。同样，在不知道你想用这种结构（而不​​是其他结构）实现什么的情况下，没有人可以肯定地说。