如何在C ++中创建多类型对象池

Question

我试图创建一个能够分配任何类型并将相同类型组合在一起的系统。

我希望以后可以使用检索每个数组，以便可以遍历每种类型。

像这样：

ObjectDatabase
{
   template<typename T>
   T* Allocate();

   template<typename T>
   Array<T>& GetObjects();
}

我的数组类型实际上是一个池，因此分配/删除速度很快。

我考虑过使用一个表示每个T的类型ID的int映射std :: map中的每个Array，但是每个T类型都需要继承自基类，因此可以将其存储在映射中，从而导致当我遍历数组时进行强制转换。

我认为这种模式以前已经做过，但是我不确定如何做。

有人可以帮忙吗？

更新：

所以我试图基本上创建一个像这样的结构：

struct ObjectDatabase
{
    Array<Entities> mEntities;
    Array<Transforms> mTransforms; 
    Array<Physics> mPhysics; 
    Array<Graphics> mGraphics; 
}

但是我想以某种方式在编译时创建一组数组。

然后提供模板函数来访问每个数组，并从每个数组进行分配

Answer 1

您可能想使用模板进行类型省略。 这是一个可能与您要查找的示例类似的示例。 ObjectDatabase类在内部使用模板和多态性来进行类型省略，因此所使用的类对它们没有任何约束（除了放置在标准库容器中的常规约束之外）。

#include <iostream>
#include <typeinfo>
#include <deque>
#include <map>
#include <cassert>
using namespace std;

struct ObjectDatabase {
    ObjectDatabase() { }

    template<typename T>
    T &allocate() {
        deque<T> &a = getObjects<T>();
        a.push_back(T());
        return a.back();
    }

    template<typename T>
    deque<T> &getObjects() {
        CollectionBase *&el = m_obdb[typeid(T).name()];
        if ( not el )
            el = new Collection<T>();
        Collection<T> *elc = dynamic_cast<Collection<T>*>(el);
        assert(elc);
        deque<T> &a = elc->elements;
        return a;
    }

    ~ObjectDatabase() {
        for ( ObDB::iterator i=m_obdb.begin(); i!=m_obdb.end(); ++i)
            delete i->second;
    }
private:
    ObjectDatabase(ObjectDatabase const &);
    ObjectDatabase &operator=(ObjectDatabase const &);

    struct CollectionBase {
        virtual ~CollectionBase() { }
    };
    template<typename T>
    struct Collection : CollectionBase {
        deque<T> elements;
    };
    typedef map<string, CollectionBase *> ObDB;
    ObDB m_obdb;
};

struct Foo {
    Foo() : name("Generic Foo") { }
    char const *name;
};

struct Bar {
    string name;
};

int main() {
    ObjectDatabase obdb;
    obdb.allocate<Foo>().name = "My First Foo";
    obdb.allocate<Bar>().name = "My First Bar";
    {
        Foo &f = obdb.allocate<Foo>();
        f.name = "My Second Foo";
        Bar &b = obdb.allocate<Bar>();
        b.name = "My Second Bar";
    }
    obdb.allocate<Foo>();
    obdb.allocate<Bar>();
    {
        cout << "Printing Foo Names\n";
        deque<Foo> &foos = obdb.getObjects<Foo>();
        for ( deque<Foo>::iterator i = foos.begin(); i!=foos.end(); ++i )
            cout << "   -> " << i->name << "\n";
    }
    {
        cout << "Printing Bar Names\n";
        deque<Bar> &bars = obdb.getObjects<Bar>();
        for ( deque<Bar>::iterator i = bars.begin(); i!=bars.end(); ++i )
            cout << "   -> " << i->name << "\n";
    }
}

当我运行该程序时，得到以下输出：

Printing Foo Names
   -> My First Foo
   -> My Second Foo
   -> Generic Foo
Printing Bar Names
   -> My First Bar
   -> My Second Bar
   -> 

这表明单个对象存储在特定于其自身类型的容器中。 您会注意到， Foo和Bar没什么特别的，只是常规的聚合。 （如果不是默认构造函数， Foo甚至会成为POD。）

========编辑========

如果您不想使用RTTI，则需要摆脱typeid和dynamic_cast 。

摆脱dynamic_cast非常简单---您实际上并不需要它。 您可以改用static_cast ； 您只是无法再使用assert()检查派生类型是否正确。 （但是，如果类型错误，无论如何都将是一个错误。）

typeid有点棘手，因为它用于构造标识符以区分不同的具体类型。 但是您可以使用一些模板魔术对象和静态对象用简单的void const *指针替换string （来自type_info::name() ）：

template<typename T>
struct TypeTag {
    static char const tag;
};
template<typename T>
char const TypeTag<T>::tag = '\0';

template<typename T>
void const *get_typemarker() {
    return &TypeTag<T>::tag;
}

现在我们可以使用get_typemarker<T>()将一个void const *键返回到映射中。 我们将ObDB密钥的类型从string更改为void const *并用get_typemarker<T>()替换typeid(T).name() get_typemarker<T>() 。 我已经对其进行了测试，它在测试程序中提供的输出与启用RTTI的版本相同。