Question

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

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

这样的事情：

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

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

My Array类型实际上是一个池，因此分配/删除速度很快。

我考虑使用表示每个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有点棘手，因为它用于构造标识符以区分不同的具体类型。但是你可以使用一些模板魔术和静态对象用一个简单的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 *键返回到地图中。我们将ObDB的密钥类型从string更改为void const *，并将typeid(T).name()替换为get_typemarker<T>()。我测试了它，它在我的测试程序中提供了与启用RTTI的版本相同的输出。

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

1 个答案: