是否存在在连续内存中存储元素数组的STL容器，其中元素大小在运行时指定

是否存在一个STL容器来存储数组中的元素在运行时指定元素大小的连续内存?

你要求的看起来像是内存池的特定实现。也许是Boost。池库或其他实现对您有用吗?如果你习惯于使用原始内存和c++特有的对象创建/销毁，那么编写自己的对象应该不难。

:

有什么东西已经这样做了吗?

对我来说，这个想法看起来像一个内存池。内存池有很多种，所以你想要的实现完全取决于你的具体需求。

这是个坏主意吗?我应该创建一个矢量并分别新建吗元素?我希望有数百万个元素。的大小范围Foo将是20到200字节。

如果你想限制内存碎片，这是个不错的主意。池通常用于解决这个问题和其他与内存组织相关的问题。

例如，这在电子游戏中非常常见，主要是在主机上，但如果你需要高性能或大量内存，也可以在PC上。

如果你正在制作一个原型，或者你没有大量的数据需要分配，我不建议你这么做。如果您这样做，那么也许首先实现隐藏在工厂后面的最简单的分配(带有vector和new)会很好，并且允许您通过使用池来替换工厂实现。这样你就可以先检查一切是否正常，然后再优化。

给定以下代码:

typedef Toffset uint; //byte offset;
typedef Ttype   uint; //enum of types
typedef std::pair<Toffset,Ttype> member;
typedef std::unordered_map<std::string, member> memberdefs;
memberdefs itemKey; 
itemKey["a"] = member(0, 0);
itemKey["b"] = member(4, 1);
itemKey["c"] = member(8, 2);
itemKey["d"] = member(12,1);
itemKey["e"] = member(16,3);
itemKey["f"] = member(17,2);

可以读入char*缓冲区，并使用简单的包装器类。仍然容易出现bug，并且非常令人困惑。这个演示没有迭代器(尽管这很简单)，并且需要一个外部缓冲区至少在类的作用域中停留一样长的时间。

class interleaved_vector {
    const char* buffer;
    size_t count;
    size_t size;
    std::shared_ptr<memberdefs> members;
public: 
    class dynamic_object {
        const char* buffer;
        std::shared_ptr<memberdefs> members;
        friend interleaved_vector;
        dynamic_object(const char* buffer_, std::shared_ptr<memberdefs> members_)
        :buffer(buffer_), members(members_)
        {}
        dynamic_object& operator=(const dynamic_object& b) = delete;
    public:
        dynamic_object(const dynamic_object& b) 
        :buffer(b.buffer), members(b.members)
        {}
        template <class T>
        T get(const std::string& member) const {
            assert((*members)[member].second > 0); //no new members, requires pos sizes
            assert((*members)[member].second == sizeof(T));
            return *reinterpret_cast<T*>(buffer+(*members)[member].first); //technically undefined I think
        };
        template <>
        T* get<T*>(const std::string& member) const {
            assert((*members)[member].second > 0); //no new members, requires pos sizes
            assert((*members)[member].second == sizeof(T));
            return reinterpret_cast<T*>(buffer+(*members)[member].first); //technically undefined I think
        };
        void* operator[](const std::string& member) const {
            assert((*members)[member].second > 0); //no new members, requires pos sizes
            assert((*members)[member].second == sizeof(T));
            return reinterpret_cast<void*>(buffer+(*members)[member].first); //technically undefined I think
        };
    };
    interleaved_vector(const char* buffer_, size_t count_, size_t size_, const memberdefs& members_)
    :buffer(buffer_), count(count_), size(size_), members(members_) 
    {}
    dynamic_object get(size_t index) const { 
        assert(index<count);
        return dynamic_object(buffer + size*index, members);
    }
    dynamic_object operator[](size_t index) const { 
        assert(index<count);
        return dynamic_object(buffer + size*index, members);
    }
    size_t size() {
        return count;
    }
};

允许这样的代码:

size_t element_size = 32;
size_t num_elements = 1000000
char * buffer = new char[num_elements*element_size];
/*read into buffer*/
interleaved_vector iv(buffer, num_elements, element_size , members);
/*interleaved_vector DOES NOT COPY BUFFER. BUFFER MUST REMAIN IN SCOPE*/
for(int i=0; i<iv.size(); ++i) {
    for(memberdefs::const_iterator j=members.begin(); j!=members.end(); ++j) {
        dynamic_object ob = iv[i];
        std::cout << "data[" << i << "]." << j.first << " = ";
        std::cout << ob.get<int>(j.first) << 'n';
    }
}

这个演示代码假设所有成员都是int型(get)，但希望你能明白这是什么意思

您可以编写自己的类，但这将是一个非常痛苦的过程。最好使用vector(或boost::ptr_vector)，它不需要您做任何努力，并且对于每个程序员来说都很容易读懂。