free()：在 tcache 2 中检测到双重释放

Question

我正在用 C++ 编写自己的动态数组类（类似于 std::vector），并且在拥有包含动态数组的动态数组时遇到问题。

基本上，当拥有所有数据类型（int、double、float、std::string 等）的数组时，没有问题，并且该类的所有功能都很好用。

当数据类型是另一个数组时，尽管有些事情发生了混乱，并且在程序末尾出现了错误（free()：在 tcache 2 中检测到双重释放）

全部代码：

动态数组.h：

#pragma once

#include <iostream>

namespace Utils
{
    template <typename T>
    class DynamicArray
    {
        private:
            size_t array_length;
            T* array;
        public:
            ~DynamicArray();
            DynamicArray();
            DynamicArray(const int& initialLength);
            void Print();
            size_t GetLength() const;
            void AddItem(const T& newItem);
            // TODO: void AddItems(const T* newItemsArray);
            void RemoveItem(int index);
            T& GetItem(int index);
            void SetItem(const int& index, const T& newValue);
            T& operator [](int index) const;
            void ResetArray(T resetValue);
    };
}

#include "DynamicArray.cpp"

动态数组.cpp：

#include "DynamicArray.h"

template<typename T>
Utils::DynamicArray<T>::~DynamicArray()
{
    std::cout << "before del" << this->array_length << "\n";
    if (this->array_length > 0)
        delete[] this->array;
    std::cout << "after del\n";
}

template<typename T>
Utils::DynamicArray<T>::DynamicArray()
{
    this->array_length = 0;
}

template<typename T>
Utils::DynamicArray<T>::DynamicArray(const int& initialLength)
{
    this->array_length = initialLength;
    T* new_array = new T[initialLength];
    this->array = new_array;
}

template<typename T>
void Utils::DynamicArray<T>::Print()
{
    for (size_t i = 0; i < this->array_length; i++)
        std::cout << this->array[i] << std::endl;
}

template<typename T>
size_t Utils::DynamicArray<T>::GetLength() const
{
    return this->array_length;
}

template<typename T>
void Utils::DynamicArray<T>::AddItem(const T& newItem)
{
    T* new_array = new T[this->array_length + 1];

    for (size_t i = 0; i < this->array_length; i++)
        new_array[i] = this->array[i];

    new_array[array_length] = newItem;

    // Releasing the memory of array
    if (this->array_length != 0)
    {
        delete[] this->array;
        this->array = nullptr;
    }

    this->array_length += 1;
    this->array = new_array;
}

template<typename T>
void Utils::DynamicArray<T>::RemoveItem(int index)
{
    T* new_array = new T[this->array_length - 1];

    int temp_index = 0;
    for (size_t i = 0; i < this->array_length; i++)
    {
        if (i != index)
        {
            new_array[temp_index] = this->array[i];
            temp_index++;
        }
    }

    // Releasing the memory of array
    delete[] this->array;
    this->array = nullptr;

    this->array_length -= 1;
    this->array = new_array;
}

template <typename T>
T& Utils::DynamicArray<T>::GetItem(int index)
{
    return this->array[index];
}

template<typename T>
T& Utils::DynamicArray<T>::operator[](int index) const
{
    return this->array[index];
}

template <typename T>
void Utils::DynamicArray<T>::ResetArray(T resetValue)
{
    for (int i = 0; i < this->array_length; i++)
        this->array[i] = resetValue;
}

template <typename T>
void Utils::DynamicArray<T>::SetItem(const int& index,const T& newValue)
{
    this->array[index] = newValue;
}

主功能：

#include <iostream>
#include "DynamicArray.h"

int main()
{
    Utils::DynamicArray<Utils::DynamicArray<double>> outputs;
    Utils::DynamicArray<double> singleOutput;
    singleOutput.AddItem(1);
    singleOutput.AddItem(1);
    outputs.AddItem(singleOutput);
}

运行程序时给出的输出：

before del2
after del
before del1
before del2
free(): double free detected in tcache 2
Aborted (core dumped)

有任何想法吗？无论我尝试什么都没有用..

Answer 1

您未能编写正确的复制构造函数和赋值运算符：

DynamicArray(DynamicArray const& rhs); // copy constructor
DynamicArray& operator=(DynamicArray const& rhs); // copy assignment

当您不自己编写这些内容时，它们是使用浅复制语义生成的。由于您的类“拥有”一个指针，如果您浅复制它，则 DynamicArray 的两个实例都拥有相同的指针，并且当一个实例被销毁时，它会销毁另一个实例指向的数据。当另一个被摧毁时，你将获得双重免费。

要编写这些内容，您需要分配内存并进行完整复制。

（您最终还需要编写移动构造函数和移动赋值运算符。）

main() 中在堆栈上声明的元素也会复制到另一个 DynamicArray 中。双重释放发生在 main 的堆栈被清理时：第一次删除是在 的析构函数中singleOutput，第二次删除是在 的析构函数中outputs，它保存了与 具有相同指针的元素singleOutput。

您还可以在默认构造函数中保留未初始化的“数组”成员。这不会将其设置为零，而是会在其中留下垃圾。（可能为零，但也可能不是。）