C++ 可以通过for循环枚举和调用不同的子类构造函数吗？

如果我有几个相同基类的子类，它们在构造函数中采用相同类型和数量的参数，类似于：

class Base {};

Class A : public Base
{
    A(arg1, arg2){};
};

Class B : public Base
{
    B(arg1, arg2){};
};

Class C : public Base
{
    C(arg1, arg2){};
};

我想知道是否有一种聪明的方法可以枚举或别名它们，以便在循环中为特定的数字调用它们的构造函数。例如，1、3和7调用A的构造函数，2和6调用B，4和5调用C

我试图避免编写switch或if语句，其中唯一的区别是类名

目前正在使用类似于：

int main() {

   for (int i = 0; i < 8; i++)
   {
       switch(i)
       {
           case 1:
           case 2:
           case 7:
              A(/*args*/);
              break;
           case 2:
           case 6:
              B(/*args*/);
              break;
           case 4:
           case 5:
              C(/*args*/);
              break;
       };
   };
};

intmain（）{
对于（int i=0；i<8；i++）
{
开关（一）
{
案例1：
案例2：
案例7：
A（/*args*/）；
打破
案例2：
案例6：
B（/*args*/）；
打破
案例4：
案例5：
C（/*args*/）；
打破
};
};
};

希望有1个表达式来处理所有实例，因为参数不变。这是我试图做的一个过于简单的想法。我使用带有多个变量的嵌套循环来实例化许多不同的对象，并将它们存储在一个容器中，以供以后使用。除了子类构造函数调用外，代码非常长且完全相同

---

是否可以使用循环增量来创建不同的子类，或者我必须坚持使用上面的冗长重复的方法？

表面上的问题似乎有点奇怪，因为您提到您正在尝试创建大量子类并将其存储在一个容器中

没有办法像您在问题中所问的那样直接调用派生构造函数的不同实例，但可能有更好的方法遵循更坚实的体系结构。根据您的描述，您的问题似乎更适合使用来创建对象，因为您提到构造函数签名都是相同的。您甚至可以使用类模板来简化此过程

下面是

A

、

B

和

C

的示例，假设所用的参数都是

int

，您应该能够执行以下操作：

int main() {

   for (int i = 0; i < 8; i++)
   {
       switch(i)
       {
           case 1:
           case 2:
           case 7:
              A(/*args*/);
              break;
           case 2:
           case 6:
              B(/*args*/);
              break;
           case 4:
           case 5:
              C(/*args*/);
              break;
       };
   };
};

struct MyFactory{
virtual~MyFactory（）=默认值；
虚拟自动生成（int arg1，int arg2）->std:：unique\u ptr=0；
};
//T将从“Base”派生（例如“A”、“B”或“C”）
模板
struct TFactory:公共MyFactory{
自动生成（int arg1，int arg2）->std:：unique\u ptr覆盖{
//分配并构造一个派生实例
返回std：：使_唯一（arg1、arg2）；
}
};

有了这个基本结构，您可以使用一个数据结构，将条件（循环的

int

计数器）分配给工厂本身——然后将其关闭以创建

Base

对象的实例。如果没有更具体的细节，很难说您的需求是什么，但作为转换原始代码的简单示例，我们可以使用关联容器（如：

//将“int”映射到工厂本身
auto factories=std:：无序_映射{}
//案件
工厂[1]=std:：make_unique（）；
工厂[2]=std:：make_unique（）；
工厂[7]=std:：make_unique（）；
//B类病例
工厂[3]=std:：make_unique（）；
工厂[6]=std:：make_unique（）；
//C类病例
工厂[4]=std:：make_unique（）；
工厂[5]=std:：make_unique（）；
//等

此时，要填充容器，只需循环并应用条件即可：

autodata=std:：vector{}；
用于（自动i=0；i制造（…）；
}

---

当然，这只是一个如何实现这一目标的高层次想法。您可能需要针对具体情况进行调整，因为不清楚您传递的参数是什么，或者这些参数如何映射在一起。如果你预计同一工厂会有很多重复的案例，你也可以使用“共享”来避免重复分配——但想法仍然是一样的。

表面上的问题似乎有点奇怪，因为您提到您正在尝试在容器中创建和存储大量这些

没有办法像您在问题中所问的那样直接调用派生构造函数的不同实例，但可能有更好的方法遵循更坚实的体系结构。根据您的描述，您的问题似乎更适合使用来创建对象，因为您提到构造函数签名都是相同的。您甚至可以使用类模板来简化此过程

下面是

A

、

B

和

C

的示例，假设所用的参数都是

int

，您应该能够执行以下操作：

int main() {

   for (int i = 0; i < 8; i++)
   {
       switch(i)
       {
           case 1:
           case 2:
           case 7:
              A(/*args*/);
              break;
           case 2:
           case 6:
              B(/*args*/);
              break;
           case 4:
           case 5:
              C(/*args*/);
              break;
       };
   };
};

struct MyFactory{
virtual~MyFactory（）=默认值；
虚拟自动生成（int arg1，int arg2）->std:：unique\u ptr=0；
};
//T将从“Base”派生（例如“A”、“B”或“C”）
模板
struct TFactory:公共MyFactory{
自动生成（int arg1，int arg2）->std:：unique\u ptr覆盖{
//分配并构造一个派生实例
返回std：：使_唯一（arg1、arg2）；
}
};

有了这个基本结构，您可以使用一个数据结构，将条件（循环的

int

计数器）分配给工厂本身——然后将其关闭以创建

Base

对象的实例。如果没有更具体的细节，很难说您的需求是什么，但作为转换原始代码的简单示例，我们可以使用关联容器（如：

//将“int”映射到工厂本身
auto factories=std:：无序_映射{}
//案件
工厂[1]=std:：make_unique（）；
工厂[2]=std:：make_unique（）；
工厂[7]=std:：make_unique（）；
//中科院