Question

通常情况下，如果您事先了解了打算创建的所有类型，您可以执行以下操作：

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

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

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

这在C ++中是否可行？在Java中有一些名为＆＃34;静态块＆＃34;，它们是在JVM加载类时执行的。

编辑：这个问题不是关于静态块 - 这只是一个例子 - 我想知道是否有某种方式，我可以执行一个方法或代码块，所以我知道运行时存在哪些类，而不是实际创建一个对象

编辑：我的意思是所有类型的集合，而不是＆＃34; maps＆＃34;，所以我可以创建每种类型的对象，而不必维护列表。

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

Foo{
   balls();
}

Boo : public Foo{
   balls();
}

Coo: public Foo{
   balls():
}

在运行时，我想知道所有派生类，所以我可以调用：

DerivedClass:balls();

编辑：注意，我不需要知道每个派生类的所有成员，我只想知道所有派生类是什么，所以我可以在每个派生类上调用ball（）。

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

但不幸的是，他正在存储一个std :: string（）。如何引用实际的类？

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

Answer 1

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

ssh -v -A ec2-user@ip

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

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

Answer 2

使用CRTP设计与接口共同的＆＃34;祖先＆＃34;：

#include <vector>
#include <iostream>

/* Base */
struct IBase
{
    virtual void balls() = 0;
    virtual IBase *clone() const = 0;

private:
    static std::vector<IBase const *> _Derived;

public:
    static void
    create_all(void)
    {
    std::cout << "size: " << _Derived.size() << "\n";
        for (IBase const *a : _Derived)
        {
            IBase *new_object(a->clone());
            (void)new_object; // do something with it
        }
    }
};

std::vector<IBase const *> IBase::_Derived;

/* Template for CRTP */
template<class DERIVED>
class Base : public IBase
{
    static bool       created;
    static Base const *_model;

public:
    Base(void)
    {
        if (not created)
        {
            _Derived.push_back(this);
            created = true;
        }
    }
};

template<class DERIVED>
bool Base<DERIVED>::created = false;
template<class DERIVED>
Base<DERIVED> const *Base<DERIVED>::_model = new DERIVED;

/* Specialized classes */
struct Foo1 : public Base<Foo1>
{
    IBase *clone() const
    {
        std::cout << "new Foo1\n";
        return new Foo1(*this);
    }
    void balls() {}
};


struct Foo2 : public Base<Foo2>
{
    IBase *clone() const
    {
        std::cout << "new Foo2\n";
        return new Foo2(*this);
    }
    void balls() {}
};


int main(void)
{
    Foo1    a;
    IBase::create_all();
}

我尝试了这个解决方案，但我不知道为什么在运行程序时没有创建static Base const *_model;。

Answer 3

您可以使用包含能够创建派生类的对象（unique_ptr）的函数的全局工厂：

#include <memory>
#include <unordered_map>
#include <typeinfo>
#include <typeindex>

// Factory
// =======

template <typename Base>
class Factory
{
    public:
    template <typename Derived>
    struct Initializer {
        Initializer() {
            Factory::instance().register_producer<Derived>();
        }
    };
    typedef std::function<std::unique_ptr<Base>()> producer_function;
    typedef std::unordered_map<std::type_index, producer_function> producer_functions;

    static Factory& instance();

    void register_producer(const std::type_info& type, producer_function producer) {
        m_producers[std::type_index(type)] = std::move(producer);
    }

    template <typename Derived>
    void register_producer() {
        register_producer(
            typeid(Derived),
            [] () { return std::make_unique<Derived>(); });
    }

    producer_function producer(const std::type_info& type) const {
        auto kv = m_producers.find(std::type_index(type));
        if(kv != m_producers.end())
            return kv->second;
        return producer_function();
    }

    const producer_functions producers() const { return m_producers; }

    private:
    producer_functions m_producers;
};

template <typename Base>
Factory<Base>& Factory<Base>::instance() {
    static Factory result;
    return result;
}

// Test
// ====

#include <iostream>

class Base
{
    public:
    ~Base() {}
    virtual void print() = 0;
};

class A : public Base
{
    public:
    void print() override { std::cout << "A\n"; }
    static void f() {}
};
Factory<Base>::Initializer<A>  A_initializer;

class B : public Base
{
    public:
    void print() override { std::cout << "B\n"; }
};
Factory<Base>::Initializer<B>  B_initializer;

class C {};

int main()
{
    auto& factory = Factory<Base>::instance();

    // unique_ptr
    auto producerA = factory.producer(typeid(A));
    if(producerA) {
        auto ptrA = producerA();
        ptrA->print();
    }

    // shared_ptr
    auto producerB = factory.producer(typeid(B));
    if(producerB) {
        std::shared_ptr<Base> ptrB(producerB());
        ptrB->print();
    }

    // missing
    auto producerC = factory.producer(typeid(C));
    if( ! producerC) {
        std::cout << "No producer for C\n";
    }

    // unordered
    for(const auto& kv : factory.producers()) {
        kv.second()->print();
    }
}

注意：工厂没有提供在没有对象的情况下调用静态成员函数的方法。

如何设计基类，因此它知道所有＆＃34;派生的＆＃34;课程，在运行时？

3 个答案: