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 ++中是不是有办法用realloc重新分配C中的连续项？

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);
}

重新分配后，std :: allocator不保留旧的已分配项

1 个答案: