C++ C++；分层类继承设计

假设我有以下应用程序逻辑：

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());
     }
};

是否有好的模式来设计配置结构？目前我正在做的是

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

---

我想有更好的办法。有什么建议吗？

这听起来像是个XY问题。你有一个特定的解决方案，你正试图得到工作，这可能是或可能不是你原来的问题的答案。此外，示例中对

new

的使用不完整，不清楚何时或如何释放

Class

对象

这样说，考虑使用接口模式——类似这样的（仍然需要工作，但这是一个开始）：

struct-IConfig{
//TODO:标识这是哪个类实例。
//和/或虚拟方法
INTA；
int b；
虚拟~IConfig（）{}
};
结构配置：公共IConfig{
INTC；
虚拟~ConfigA（）{}
};
结构配置B:公共IConfig{
int d；
虚拟~ConfigB（）{}
};
类IClass{
//TODO:标识这是哪个类实例。
//和/或虚拟方法
虚拟~IClass（）{}
};
A类：公共IClass{
公众：
A类（常数IConfig和iconf）{
ConfigA&aconf=动态广播（iconf）；
}
虚拟~ClassA（）{}
};
B类：公共IClass{
公众：
B类（常数IConfig和iconf）{
ConfigB&bconf=动态广播（iconf）；
}
虚拟~ClassB（）{}
};
类应用程序{
IConfig*config；//如果
I类*cls；
初始无效（IConfig配置）{
如果（条件1）
cls=新类别A（配置）；
否则，如果（条件2）
cls=新类别B（配置）；
其他的
// ...
}
};

如果传递给

initial

的

IConfig

类型为

ConfigA

以匹配所创建的类，请确保使用这样的解决方案

cond1

将为真。您可以添加更多检查，以确保接口本身也是如此。一个返回常量的虚拟方法应该足够好了，但它实际上取决于您在执行此操作时尝试实现的目标，因为它看起来已经是一个混乱的方法了

例如，

IConfig

的本地配置可以用来确定这两个类——加载哪个类，而哪个类又决定应该使用哪个配置类，等等

---

事后考虑-在这种情况下，您可能希望让每个

类

都有自己的

IConfig

实现，它让

App

（使用

IConfig

数据）确定要创建的类。同样，在不知道您试图通过这种结构（与其他结构相反）实现什么的情况下，没有人能够确定。

什么是

cond1

和

cond2

？创建类

classA

和

classB

后，您希望如何处理这些类？让他们泄漏听起来不是一个好的选择…这是不完整的代码。我的意思是有一些配置分支。分支可以在ConfigA内继续。请提供一个。@skypjack对此表示抱歉，但它已经是一个mvce。这是关于如何设计顶层配置结构的。这是一种变异的工厂模式吗？谢谢。你的解决方案是我现在能得到的最好的。因为我的应用可能包含动态派生类，不同的类有不同的配置。整个应用程序配置在单个文件中指定。我试图找到一种适合这种情况的配置接口设计模式。

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