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

Question

我正在尝试创建一个能够分配任何类型并将相同类型分组到数组中的系统。

我希望以后能够检索每个数组，这样我就可以遍历每个类型。

像这样:

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

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

我的 Array 类型实际上是一个池，所以分配/删除很快。

我考虑过使用表示每个 T 的类型 id 的 int 来映射 std::map 中的每个数组，但是每个类型 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有点棘手，因为它用于构造标识符以区分不同的具体类型。但是您可以使用一些模板魔术和静态对象来替换 string (来自 type_info::name() )与一个简单的 void const *指针:

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 * key 进入 map 。我们更改 ObDB 的类型的 key 来自 string至 void const *并替换 typeid(T).name()与 get_typemarker<T>() .我已经对其进行了测试，它在我的测试程序中提供了与支持 RTTI 的版本相同的输出。