c++分层类继承设计

C++ hierarchical class inheritance design

本文关键字：继承 分层 c++      更新时间：2023-10-16

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

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: 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将是真，如果传递给initial的IConfig是ConfigA类型，以匹配正在创建的类。您可以在接口本身中添加更多检查以确保是这种情况。一个返回常量的虚方法应该足够好了，但这实际上取决于你想要实现什么，因为它看起来已经是一个混乱的方法了。

例如，也许IConfig的本地配置可以用来确定两者-加载哪个类，反过来决定应该使用哪个配置类，等等。

事后考虑-在这种情况下，您可能希望让每个Class都有自己的IConfig实现，这让App(使用IConfig数据)决定创建哪个类。同样，在不知道您试图通过这种结构(而不是其他结构)达到什么目的的情况下，没有人可以确定。

相关文章：