free：在tcache 2中检测到双倍free

问题描述

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

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

如果数据类型是另一种数组，尽管有些混乱，并且在程序末尾出现错误（free（）：在tcache 2中检测到double free）

所有代码：

DynamicArray.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"

DynamicArray.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)

有什么想法吗？不管我尝试了什么都没用。

解决方法

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

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

当您不自己编写这些代码时，它们是使用浅拷贝语义生成的。由于您的类“拥有”一个指针，因此，如果您对其进行浅表复制，则DynamicArray的两个实例都拥有相同的指针，并且当一个实例被销毁时，它将销毁另一个指针指向的数据。当另一个被销毁时，您将获得双倍的自由。

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

（您最终还希望编写一个 move 构造函数和 move分配运算符。）

在main（）中在堆栈上声明的元素也将复制到另一个DynamicArray中。清除main堆栈时会发生双倍释放：第一个删除在singleOutput的析构函数中，第二个删除在outputs的析构函数中，后者包含具有相同指针的元素为singleOutput。

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