0

我有一个类，它有几个派生类，每个类都有自己的构造函数。

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 的构造函数时，现在我在派生类之间略有不同的 member_data 值的初始化中有一堆程序命令，例如，

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

并有一个类 initializer() 实现不同类的初始化步骤。我想这大概是受到策略模式的启发。有人对这种方法是否合适或明智有任何建议吗？或者它只是将问题归结为初始化类并引入了额外的复杂层。如果做这样的事情是一个坏主意，可以做些什么来避免构造函数是一个长的 C 程序？

编辑：正如一些人指出的工厂指定不正确。在我给出的示例中，它仍然没有真正完善，但它并不像以前那样偏离标准。

4

3 回答 3

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();
 }
}
于 2013-06-21T15:41:53.520 回答
1

您可能想看看std::generate与适当的生成器仿函数的结合。你的生成器可以完成初始化你想要的数据的艰苦工作，保持你的类的界面相对干净（如果你想保持私有，你可能需要让你的生成器成为你的类的朋友）。

于 2013-06-21T15:31:23.843 回答
0

该标准说您当前的“解决方案”格式不正确：

ISO IEC 14882:2011, §12.1/10

不应为构造函数指定返回类型（甚至 void）。构造函数主体中的 return 语句不应指定返回值。不得使用施工人员的地址。

你想要另一个工厂模式。

也许您可以从这里使用一些东西：如何设计一个简单的 C++ 对象工厂？

于 2013-06-21T15:33:59.087 回答