Question

我有一个包含多个派生类的类，每个类都有自己的构造函数。

class A
    {
    public:
       static A *create_new_A(int child_ID);

       member_data;
       void method();
    };

class A_child_0 : public A
    {
    A_child_0(int child_ID);
    //stuff
    };

class A_child_1 : public A
    {
    A_child_1(int child_ID);
    //stuff
    };
    etc...

并在主文件中调用这些内容：

A **array;
array = new A *[nchildren];
for (int i = 0 ; i < nchildren ; i++) 
    {
    array[i] = A->create_new_A( i );
    }

其中A是一个类似于：

的工厂

A* A::create_new_A(int child_ID)
   {
   if (child_ID == 0) 
       {
       return new A_child_0(child_ID);
       }
   if (child_ID == 1)
       {
       return new A_child_1(child_ID);
       }  
   }

现在，当调用A_child_n的构造函数时，我现在在初始化中有一堆过程命令，这些命令在派生类之间略有不同，例如，

A_child_0(int child_ID)
    {
    member_data.vector1[0] = 0;
    for (i = 0; i < 200; i++)
         member_data.vector2[0] = i;
    read_in_conf_file("conf.txt") 
    // etc....
    }

A_child_1(int child_ID)
    {
    member_data.vector1[0] = 0;
    for (i = 0; i < 50; i++)
      member_data.vector2[0] = i*i;
    read_in_conf_file("conf.txt") 
     // etc....
    }

我很好奇的是，是否有更好的方法来解决这个问题。现在我正在考虑封装很多这些批评步骤，所以它读起来像

A_child_0(int child_ID)
    {
    initializer_class *intializer;
    initializer->initialize(child_ID);
    }

A_child_1(int child_ID)
   {
   initializer_class *intializer;
   initializer->initialize(child_ID);
   }

并有一个类初始化程序（），它实现了不同类的初始化步骤。我想这是战略模式的松散启发。是否有人对这种方法是否合适或合理有任何建议？或者它只是将问题归咎于初始化类并引入了一层复杂的附加层。如果做这样的事情是一个坏主意，可以做些什么来试图避免让构造函数成为一个长C程序？

编辑：有人指出工厂指定不正确。在我给出的例子中，它仍然没有得到真正的抛光，但它并没有像以前那样令人印象深刻。

Answer 1

您是否可以让用户进行初始化？

struct Base{
 std::vector<int> data;
 int minDefaultSize;
 Base(const int defaultSize = 50): minDefaultSize(defaultSize), data(std::vector<int>(defaultSize,0))  {
 }
 virtual void initialize(){ 
   for(int i = 0; i < data.size(); ++i){ data[i] = i; }
 }
 ~virtual Base(){};
};

struct D1: Base{
 D1(): Base(100){}
 virtual void initialize(){ 
   for(int i = 0; i < data.size(); ++i){ data[i] = i*i; }
 }
};

std::shared_ptr<Base> createIt(const int type){
 type % 2 == 0 ? return std::shared_ptr<Base>(new Base()) : return std::shared_ptr<Base>(new D1());
}
int main(){
 std::vector< std::shared_ptr<Base> > polyType;
 for(int i = 0; i < 5; ++i){ 
  polyType.push_back(createIt(i) ); 
  polyType.back()->initialize();
 }
}

Answer 2

您可能希望查看std::generate并结合适当的生成器函数。您的生成器可以完成初始化所需数据的艰苦工作，保持您的类的界面相对干净（如果您想保持私密性，您可能需要将您的生成器作为您班级的朋友）。

Answer 3

标准说你当前的“解决方案”是不正确的：

ISO IEC 14882：2011，§12.1/ 10

不应为构造函数指定返回类型（甚至无效）。构造函数体中的return语句不应指定返回值。不得采用构造函数的地址。

您希望拥有其他工厂模式。

也许您可以使用此处的内容：How to design a simple C++ object factory?

C ++在构造函数中使用“初始化器”类是否合适/合理？

3 个答案:

ISO IEC 14882：2011，§12.1/ 10