通常，如果您事先知道要创建的所有类型，就可以这样做:

typedef enum{
    BASE_CREATURE_TYPE = 0,
    ANIMAL_CREATURE_TYPE,
    ...
}CREATURE_TYPES

但这变得很乏味，因为每次创建新类时，都需要更新枚举。此外，CREATURE_TYPES 仍然只是枚举中的项目 - 如何绑定(bind)到实际类？

我想知道是否有某种方法，我可以只编写类，并在运行时创建一个包含所有类型的集合，而无需实际实例化对象。

这在 C++ 中可行吗？在 Java 中有一种叫做“静态 block ”的东西，它在 JVM 加载类时执行。

编辑:这个问题与静态 block 无关——这只是一个例子——我想知道是否有某种方法可以执行一个方法或代码块，这样我就知道运行时存在哪些类，而无需实际创建一个对象

编辑:我指的是所有类型的集合，而不是“映射”，因此我可以创建每种类型的对象，而无需维护列表。

编辑:我想要这个的原因是因为我正在尝试创建一个函数，该函数可以调用作为应用程序一部分的所有派生类的方法。例如，假设我有几个类都派生自 Foo 类，并且有一个 balls():

Foo{
   balls();
}

Boo : public Foo{
   balls();
}

Coo: public Foo{
   balls():
}

在运行时，我想知道所有的派生类，这样我就可以调用:

DerivedClass:balls();

编辑:注意，我不需要知道每个派生类的所有成员，我只想知道所有派生类是什么，所以我可以对每个派生类调用 balls()。

编辑:这个问题类似:How to automatically register a class on creation

但不幸的是，他存储的是一个std::string()。如何指代实际类(class)？

编辑:在下面 Smeehey 的回答中，在 main 方法中，我将如何实际创建每个类的实例，并同时调用静态和非静态方法？

最佳答案

您可以为所有类创建一个静态注册表，并使用几个辅助宏在其中注册新类型。下面是一个基本的工作演示，它从 Base 创建了 2 个派生类。要添加新类，您只需使用显示的两个宏 - 一个在类内，一个在类外。注意:该示例非常简单，并不关心检查重复项或其他错误条件等内容以最大限度地提高清晰度。

class BaseClass
{
};

class Registry
{
public:
    static void registerClass(const std::string& name, BaseClass* prototype)
    {
        registry[name] = prototype;    
    }

    static const std::map<std::string, BaseClass*>& getRegistry() { return registry; };

private:
    static std::map<std::string, BaseClass*> registry;
};

std::map<std::string, BaseClass*> Registry::registry;

#define REGISTER_CLASS(ClassType) static int initProtoType() { static ClassType proto; Registry::registerClass(std::string(#ClassType), &proto); return 0; } static const int regToken;
#define DEFINE_REG_CLASS(ClassType) const int ClassType::regToken = ClassType::initProtoType(); 

class Instance : public BaseClass
{
    REGISTER_CLASS(Instance)
};

DEFINE_REG_CLASS(Instance)

class OtherInstance : public BaseClass
{
    REGISTER_CLASS(OtherInstance)
};

DEFINE_REG_CLASS(OtherInstance)

int main()
{
    for(auto entry : Registry::getRegistry())
    {
        std::cout << entry.first << std::endl;
    }
    return 0;
}

上面注册了派生类的原型(prototype)，例如可以用于复制构造其他实例。作为替代方案，根据 OP 的要求，您可以拥有一个注册工厂方法而不是原型(prototype)的系统。这允许您使用具有任何特定签名的构造函数而不是复制构造函数来创建实例:

class BaseClass
{
};

class Registry
{
public:
    using factoryMethod = BaseClass* (*)(int a, int b, int c);

    static void registerClass(const std::string& name, factoryMethod meth)
    {
        registry[name] = meth;    
    }

    static BaseClass* createInstance(const std::string& type, int a, int b, int c)
    {
        return registry[type](a, b, c);
    }

    static const std::map<std::string, factoryMethod>& getRegistry() { return registry; };

private:
    static std::map<std::string, factoryMethod> registry;
};

std::map<std::string, Registry::factoryMethod> Registry::registry;

#define REGISTER_CLASS(ClassType) static BaseClass* createInstance(int a, int b, int c)     \
                                  {                                                         \
                                      return new ClassType(a,b,c);                          \
                                  }                                                         \
                                  static int initRegistry()                                 \
                                  {                                                         \
                                       Registry::registerClass(                             \
                                           std::string(#ClassType),                         \
                                           ClassType::createInstance);                      \
                                       return 0;                                            \
                                  }                                                         \
                                  static const int regToken;                                \

#define DEFINE_REG_CLASS(ClassType) const int ClassType::regToken = ClassType::initRegistry(); 

class Instance : public BaseClass
{
    Instance(int a, int b, int c){}

    REGISTER_CLASS(Instance)
};

DEFINE_REG_CLASS(Instance)

class OtherInstance : public BaseClass
{
    OtherInstance(int a, int b, int c){}

    REGISTER_CLASS(OtherInstance)
};

DEFINE_REG_CLASS(OtherInstance)

int main()
{
    std::vector<BaseClass*> objects;
    for(auto entry : Registry::getRegistry())
    {
        std::cout << entry.first << std::endl;
        objects.push_back(Registry::createInstance(entry.first, 1, 2, 3));
    }
    return 0;
}

关于c++ - 如何设计一个基类，使其在运行时知道所有 "derived"类？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37746879/