std::allocator 在重新分配后不保留旧分配的项目

Question

我正在尝试实现一个分配内存块的 Vector 类，如果它需要包含更多项目，最终会重新分配它。
我正在使用 std::allocator 来执行此操作：

#include <iostream>
#include <stdexcept>

using namespace std;

template <class T>
class Vector
{
private:
    T* data;
    allocator<T> data_all;
    int length;
    int _size;
    static const int block_size=10;
    void init()
    {
        length=0;
        _size=block_size;
        data=data_all.allocate(block_size,NULL);
    }
public:
    Vector()
    {
        init();
    }
    int size() const
    {
        return length;
    }
    void push_back(T item)
    {
        length++;
        if(length > _size)
        {
            _size+=block_size;
            data=data_all.allocate(_size,data);
        }
        data_all.construct(&data[length-1],item);
    }
    T& operator[] (int i)
    {
        if(i<0 || i>= length)
            throw out_of_range("The index is out of vector range");
        return data[i];
    }
};

int main(int argc, char** argv)
{
    Vector<int> v;
    for(int i=0; i<20; i++)
        v.push_back(i);
    for(int i=0; i<v.size(); i++)
        cout << v[i] << "\t";
    return 0;
}

问题是先前分配的项目没有保留，它打印：

0   0   0   0   0   0   0   0   0   0   10  11  12  13  14  15  16  17  18  19  

代替：

0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  

为什么会有这种行为？在 C++ 中没有办法像在 C 中使用 realloc 重新分配连续项目吗？

Answer 1

allocate 的第二个参数只是一个提示，分配器 可以 用来尝试返回靠近旧内存的新内存，但被 std::allocator 忽略，并且对向量毫无用处- 类似容器，因为无论如何所有元素都彼此靠近，因为它们位于一个连续的块中。

您似乎希望它复制现有数据。它不会。你必须这样做，从旧内存块复制到新内存块。

您还泄漏了旧内存。你需要释放它。

你想要这样的东西：

void push_back(const T& item)
{
    if (length == _size)
    {
        T* new_data = data_all.allocate(_size+block_size);
        // N.B. if any of the following copies throws new_data will be leaked
        std::uninitialized_copy(data, data+length, new_data);
        std::destroy(data, data+length);
        data_all.deallocate(data, _size);
        data = new_data;
        _size+=block_size;
    }
    data_all.construct(&data[length++],item);
}