C++ 释放内存

Question

我想问一下如何正确释放程序中的内存。（free()：在 tcache 2 超时中检测到双重释放：受监控的命令转储核心）

在 adVersion 方法中，我创建一个包含当前实例值的链接列表。在变量 m_History 中，我引用了以下元素。在该方法中，我将实例的当前内容添加到该链表的末尾。

在复制构造函数中，我复制属于给定实例的所有内容和链接列表。

我附上了程序的重要部分，并在链接中附上了整个程序https://onecompiler.com/cpp/3xzaa3mfh

//编辑：我几乎改变了 adVersion 方法，请你检查一下是否可以？

    class CFile
    {
            uint8_t *m_Data;
            uint32_t m_Len;
            uint32_t m_Position;
            uint32_t m_Capacity;
    
            size_t m_LenHistory;
            CFile *m_History;
    
    };
    
    CFile::CFile(void)
    :m_Data(nullptr), m_Len(0), m_Position(0), m_Capacity(0),m_LenHistory(0), m_History(nullptr)
    {
    }
    
    CFile::~CFile (void)
    {
        delete[] m_Data;
    
        //Delete linked list
        while (m_History)
        {
            CFile* old = m_History;
            delete[] old->m_Data;
            m_History = m_History->m_History;
            delete old;
        }
        m_History = nullptr;
    }
    
    CFile* copyLinkedList(CFile *list)
    {
        if(list == nullptr) return nullptr;
    
        CFile* result = new CFile;
        result->m_Capacity = list->m_Capacity;
        result->m_Len = list->m_Len;
        result->m_Position = list->m_Position;
        result->m_LenHistory = list->m_LenHistory;
        result->m_Data = new uint8_t[list->m_Capacity];
        memcpy(result->m_Data, list->m_Data, result->m_Len);
        result->m_History = copyLinkedList(list->m_History);
        
        return result;
    }
    
    // Copy construkctor
    CFile::CFile(const CFile &src)
    : m_Data(new uint8_t[src.m_Capacity]),
      m_Len(src.m_Len),
      m_Position(src.m_Position),
      m_Capacity(src.m_Capacity),
      m_LenHistory(src.m_LenHistory)
    {
        memcpy(m_Data, src.m_Data, m_Len);
        m_History = copyLinkedList(src.m_History);
    }
    
    void CFile::copyWithoudLinkedList( CFile &src )
    {
        m_Capacity = src.m_Capacity;
        m_Len = src.m_Len;
        m_LenHistory = src.m_LenHistory;
        m_Position = src.m_Position;
        m_Data = new uint8_t[src.m_Capacity];
    
        memcpy(m_Data, src.m_Data, m_Len);
    }
    
    void CFile::addVersion  ( void )
{
    CFile *tmp = m_History;
    CFile *prev;

    if(!tmp)
    {
        tmp = new CFile();
        tmp->copyWithoudLinkedList(*this);
        this->m_History = tmp;
        this->m_History->m_History = nullptr;
        m_LenHistory++;
    }
    else
    {
        while(tmp)
        {
            prev = tmp;
            tmp = tmp->m_History;
        }
        
        tmp = new CFile();
        tmp->copyWithoudLinkedList(*this);
        prev->m_History = tmp;
        prev->m_History->m_History = nullptr;
        m_LenHistory++;
   }
}

Answer 1

避免手动内存处理出现问题的最佳方法就是不使用任何内存。C++ 标准库的大部分内容都在那里，因此您不必费心实现标准数据结构。

首先，不要使用 using uint8_t *m_Data;（这需要分配和释放内存），而是使用std::vector< uint8_t >它来为你做这件事。

其次，class CFile从做两件事——保存数据和实现列表——转变为只做一件事情——保存数据。

#include <vector>

struct CFile
{
    std::vector< uint8_t > m_Data;
    // ...
};

CFile第三，通过标准容器获取实例的链表std::forward_list：

#include <forward_list>

std::forward_list< CFile > cfile_list;
CFile cfile { { 0x23, 0x42, 0xff } };
cfile_list.push_front( cfile );

由于您现在不必在任何地方手动分配内存，因此也不必手动释放它。