c++ - 如何在 C++ 中重新分配？

Question

以下代码构成一个MCVE ，这重现了我想问的问题，但它不是真正的代码。真正的代码要复杂得多，所以我写这篇文章来演示这个问题。

我正在寻找的关键特性是能够增长一个动态分配的数组，请不要建议使用 STL 因为它被明确禁止。此代码用于教育目的，因此存在限制。

#include <cstring>
#include <iostream>

class Value
{
    public:
        Value(int value = 0);
        Value(const Value &value);
        Value &operator =(const Value &other);
        ~Value();

        operator int() {return *m_absurdPointer;}

    private:
        int *m_absurdPointer;
};

Value::Value(int value) :
    m_absurdPointer(new int[1])
{
    *m_absurdPointer = value;
}

Value::Value(const Value &value)
{
    m_absurdPointer = new int[1];
    memcpy(m_absurdPointer, value.m_absurdPointer, sizeof(*m_absurdPointer));
}

Value &Value::operator =(const Value &other)
{
    m_absurdPointer = new int[1];
    memcpy(m_absurdPointer, other.m_absurdPointer, sizeof(*m_absurdPointer));

    return *this;
}

Value::~Value()
{
    delete[] m_absurdPointer;
}

class ValueArray
{
    public:
        ValueArray();
        ~ValueArray();

        void append(const Value &value);
        void show() const;

    private:
        Value *m_array;
        unsigned int m_capacity;
        unsigned int m_length;
};


ValueArray::ValueArray() :
    m_array(nullptr)
  , m_capacity(0)
  , m_length(0)
{
}

ValueArray::~ValueArray()
{
    delete[] m_array;
}

void
ValueArray::append(const Value &value)
{
    if (m_length >= m_capacity)
    {
        Value *newarray;
        unsigned int unitSize;

        unitSize = 1;       
        newarray = new Value[m_capacity + unitSize];

        if ((m_capacity > 0) && (m_array != nullptr))
            memcpy(newarray, m_array, m_capacity * sizeof(*m_array));
        delete[] m_array;

        m_array = newarray;
        m_capacity += unitSize;
    }
    m_array[m_length++] = value;
}

void
ValueArray::show() const
{
    for (size_t i = 0 ; i < m_length ; ++i)
        std::cout << static_cast<int>(m_array[i]) << std::endl;
}

int
main(void)
{
    ValueArray example;

    for (int i = 0 ; i < 10 ; ++i)
        example.append(Value(i));
    example.show();

    return 0;
}

如您所见，它会导致双重 free 问题，因为 delete[] m_array; 在之后调用类 Value 的析构函数它已将值复制到重新新ed 数组。

我尝试使用 malloc()/realloc() 来实现，但我需要调用 Value() 的析构函数new 是必需的，因为我不能使用 free()。

如何防止这种情况发生？如果我删除 delete[] m_absurdPointer;，双重释放当然会消失，但会出现内存泄漏。

Answer 1

您基本上想要实现自己的 vector 类，对吧？

好的，首先要做的是:据我所知，您不能增加以前分配的内存。至少不是标准分配器。

所以你需要分配一个新的、更大的内存块。

您可以使用新的标准方式执行此操作:

Type * newdata = new Type[size];

在这种情况下，将为每个新元素调用 Type 类的构造函数，这是 size 次。

要将旧数据放入新数组，您需要将其复制或移动到那里:

for (size_t it = 0; it < oldsize; ++it) {
  newdata[it] = olddata[it];
  // newdata[it] = std::move(olddata[it]);
}

这就是 std::copy 的内容。 std::move 正在做。 (您也可以在循环内使用 std::swap。)

为此，Type 类需要默认构造函数和复制或移动赋值的有效实现。

您正在使用 memcpy。在 C++ 中，这通常是一个坏主意:你实现的赋值运算符没有被调用，因此你的旧数组中的对象和原始拷贝都使用相同的指针，这就是你得到双重释放的原因，很明显。

您还可以分配原始内存并使用 placement new 从旧对象复制或移动构造新对象:

void * memory = new char[size * sizeof(Type)];
for (size_t it = 0; it < oldsize; ++it) {
  new (memory + it * sizeof(Type)) Type(olddata[it]); // copy
}

以上只是一个例子，对于真正的代码你也需要考虑对齐。

最后，我确定您可以通过某种方式欺骗默认分配器以释放您的(旧)内存而不破坏其中的对象，这允许您使用制作的原始拷贝 memcpy。虽然这将是一种 hack 并且可能会破坏复杂的类，但这不是 C++ 的实现方式。

惯用的方法是将旧对象复制或移动到新存储(通过赋值或构造)。