如何创建一个接口以允许在 C++ 中构造不同的嵌套派生 类？

Question

我的目标是从接口构造一个派生的 classes 嵌套 class。然而，嵌套的 classes 没有相同的构造函数。问题是我如何制作一个界面来创建两个不同的“子嵌套”classes.

约束条件：

• 不能使用堆
• 嵌套类'方法在构造之前不能被调用
• C++ 17

ITest::INestedTest* MakeTest(ITest* test, ITest::Config config)
{
  // Can't call directly because it's not on the interface i.e. test.InitializeNestedTest ...
  // Only workable situation is this:
  if (condition)
  {
     auto myTest = static_cast<Test2::Test*>(test);
     int p = 2;
     return myTest->InitalizeNestedTest(config, p);
     // ERROR function returning abstract class not allowed
  } else {
     auto myTest = static_cast<Test1::Test*>(test);
     return myTest->InitalizeNestedTest(config); 
     // ERROR function returning abstract class not allowed
  }   
  
}

这个静态转换没有return我之前想要的，因为我return指向本地定义变量的指针，这在评论中指出。由于它是抽象的 class，因此我如何能够从中 return 一个 class，我是否需要再次转换它或创建多个函数？

Test1::Test myTest; 
auto myNestedTest = myTest.InitializeNestedTest(config);

我想到了几个选项，但 none 个似乎是正确的，或者我不完全确定如何实施它们

1. 在接口上为每种类型重载虚函数，然后在子层上重载它们class（不确定是否可能，但似乎不是正确的做法）
2. 扩展Config struct Test2命名空间，使其包含参数p，使它们都具有相同的原型并将其放在接口上。 （是否可以从界面“扩展”结构？）
3. 也许使用不同类型的演员表，或者以不同的方式这样做？

我已经包含了我的接口和两个子class的定义以供参考。

class ITest
{
    //other things in ITest.hpp not relevant to question
public:
  struct Config
  {
      int a;
      bool enable;
  };
    class INestedTest
    {
    public:
        virtual void Enable() const = 0;
        virtual void Configure(Config const& config)
        {
            if(config.enable)
            {
                Enable();
            }
        }
    };
};

namespace Test1
{
    class Test : public ITest
    {
    public:
        class NestedTest : public ITest::INestedTest
        {
        public:
            NestedTest(Config const& config)
            {
                Configure(config);
            }
            void Enable() const override
            {
                //impl
            }
        }; // End NestedTest
        
        NestedTest InitalizeNestedTest(Config const& config)
        {
            return NestedTest(config);
        }
        
    };
};

namespace Test2
{
    class Test : public ITest
    {
    public:
        class NestedTest : public ITest::INestedTest
        {
        public:
            using Parameter = int;
            NestedTest(ITest::Config const& config, Parameter p)
            {
                Configure(config);
            }
            void Enable() const override
            {
                //impl
            }
        }; // End NestedTest
        
        NestedTest InitalizeNestedTest(Config const& config, NestedTest::Parameter p)
        {
            return NestedTest(config, p);
        }
        
    };
};

Answer 1

也许您可以将对象设为静态，以便在编译时在 RAM 中声明它（而不是堆或堆栈）。