一个C++的内存池和内存管理的实现（六）

最新推荐文章于 2022-12-14 21:48:40 发布
原创 最新推荐文章于 2022-12-14 21:48:40 发布 · 491 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C++内存管理

本文详细介绍了内存泄露的检测与管理方法，包括自动查找内存泄露的功能实现，通过添加记录文件名、行号、引用计数等信息来追踪内存分配与释放情况。文中还涉及到内存池的使用，以及在内存申请、释放时的合法性检测与泄露检查，最后在程序退出时进行泄露信息的打印。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

这章是加入内存泄露的自动查找的。之前已经发布了，优快云不知道给整哪去了，我自己也没存档。懒得再仔细重写了，随便写一下。

泄露工具有不少，比如微软自己的_CrtSetDbgFlag，_CrtSetBreakAlloc。但是牵涉到静态变量和跨DLL的申请释放时，很多工具会给出不准确的信息。自己做一个吧，调试起来做改动也方便，可以做到有的放矢。

首先得在前缀里加几个字段。不过加了之后会比较臃肿，所以用个USE_SMART_HEAP宏控制，不需要作检查的时候就关掉。nRefCnt、szToken、bIsArray是以后越界检查才用到的，现在不用管它。

    _declspec(align(ALIGNMENT)) struct PrefixNest {
        ...
        MemPageHeader* pPage;      // page that contains the memory block
#if defined USE_SMART_HEAP
        char szFileName[32];       // 文件名
        int nLineNumber;           // 行号
        int nRefCnt;               // 引用数（类似智能指针）
        char szToken[4];           // signature for being a Prefix
        bool bIsArray;             // 是否数组
#endif
    };

然后MemPool加几个相关函数的定义

    class MemPool
    {
        ...
    private:
#if defined USE_SMART_HEAP
        bool ArePagesAllClear();  // 是否所有页都已回收完毕其下的内存块
        void RenderDesc(Prefix*, char*, int);  // 输出泄露信息
#endif      
        ...
    public:
#if defined USE_SMART_HEAP
        // Display a symbolic dump of the heap (i.e. memory pool) by walking the heap and displaying all objects in the heap.
        void WalkHeap();
        // Does the given memory pointer point anywhere into the heap.
        bool IsPtrOk(void* pMem);
        // Verify a given memory pointer
        bool VerifyHeapPointer(void* pMem);
#endif
        ...
    }

接下来在内存申请的时候，添加语句用来记录相关文件名和行数。以下所有泄露检查的相关添加和改动都在#if defined USE_SMART_HEAP和#endif的宏块里。

void* MemPool::Alloc(int nSize, const char* const szFileName, int nLine, bool bIsArray)
{
    if (nSize < MAX_ALLOC_FROM_PAGE)
    {
        ...
        // Check if there is free memory in block pool of the corresponding size
        if (m_ppBlockPools[i]->d.pNext)  // an available memory block in pool
        {
            ...
            pPrefix->d.pPostfix->nActualSize = nSize;  // actual size requested
#if defined USE_SMART_HEAP
            if (szFileName) {
                strcpy_s(pPrefix->d.szFileName, 31, szFileName); pPrefix->d.szFileName[31] = 0;
            } else
                pPrefix->d.szFileName[0] = 0;  // null string
            pPrefix->d.nLineNumber = nLine;
            pPrefix->d.bIsArray = bIsArray;
            pPrefix->d.nRefCnt = 0;
#endif
            ...
        }

        // Allocate from the page
        ...
        do {
            for (MemPageHeader *pPage = m_pFirstPage; pPage != NULL; pPage = pPage->d.pNext)
            {
                if (pPage->d.pEnd >= pPage->d.pLast + sizeof(Prefix) + nAllocSize + sizeof(Postfix))
                {
                    ...
                    pPrefix->d.pPage = pPage;
#if defined USE_SMART_HEAP
                    if (szFileName) {
                        strcpy_s(pPrefix->d.szFileName, 31, szFileName); pPrefix->d.szFileName[31] = 0;
                    } else
                        pPrefix->d.szFileName[0] = 0;  // null string
                    pPrefix->d.nLineNumber = nLine;
                    pPrefix->d.bIsArray = bIsArray;
                    *((int*) pPrefix->d.szToken) = PREFIX_SIG;  // 加个签名，表明是个前缀
                    pPrefix->d.nRefCnt = 0;
#endif
                    pPage->d.pLast += sizeof(Prefix) + nAllocSize + sizeof(Postfix);
                    ...
                }
            }
        } while (AllocPage());  // now we should allocate one more page
        ...
    }
    ...
}

void* MemPool::AllocLarge(int nSize, const char* const szFileName, int nLine, bool bIsArray)
{
    ...
    if (pPrefix)
    {
        ...
        pPrefix->d.pPage = NULL;  // indicating it is not allocated from any pages
#if defined USE_SMART_HEAP
        if (szFileName) {
            strcpy_s(pPrefix->d.szFileName, 31, szFileName); pPrefix->d.szFileName[31] = 0;
        } else
            pPrefix->d.szFileName[0] = 0;  // null string
        pPrefix->d.nLineNumber = nLine;
        pPrefix->d.bIsArray = bIsArray;
        *((int*) pPrefix->d.szToken) = PREFIX_SIG;
        pPrefix->d.nRefCnt = 0;
#endif
        ...
    }
    ...
}

接下来在Free函数加一段，用来对每个要释放的指针对象作合法性检测。这个无关泄露，但也提一下吧。

void MemPool::Free(void* pMem)
{
    SYNCHRONIZATION();

#if defined USE_SMART_HEAP
    if (!VerifyHeapPointer(pMem)) {
        std::cerr << "Memory block bad" << std::endl;
        return;
    }
#endif
    ...
}

泄露的检查是在MemPool的析构里做的。这样当程序退出时，会打印泄露信息

MemPool::~MemPool()
{
    // Do some cleanups
    for (Cleanup *p = m_pCleanups; p != NULL; p = p->pNext)
    {
        if (p->pHandler)
            p->pHandler(p->pParam);
    }

#if defined USE_SMART_HEAP
    WalkHeap();
#endif
    ...
}

OK，接下来是泄露检查的实现部分

void MemPool::WalkHeap()
{
    if (m_pLarge->d.pNext || !ArePagesAllClear())
    {
        OutputDebugStringA("Detected memory leak:\n");

        char buffer[100];
        if (m_pLarge->d.pNext)  // 大内存泄露
        {
            for (Prefix *pCur = m_pLarge->d.pNext; pCur != NULL; pCur = pCur->d.pNext)
            {
                if (!VerifyHeapPointer(&pCur[1])) {
                    OutputDebugStringA("Memory block bad"); break;
                }
                RenderDesc(pCur, buffer, 100);  // 输出泄露信息
                OutputDebugStringA(buffer);
            }
        }
        else  // 页里有泄露
        {
            for (MemPageHeader *p = m_pFirstPage; p != NULL; p = p->d.pNext)
            {
                Prefix *pPrefix = (Prefix*) ((char*) p + sizeof(MemPageHeader));
                while ((char*) pPrefix < p->d.pLast)  // 遍历页内所有未能回收的内存块
                {
                    if (!IsInBlockPool(pPrefix)) {  // 如果不在任何尺寸的池中
                        RenderDesc(pPrefix, buffer, 100);  // 输出泄露信息
                        OutputDebugStringA(buffer);
                    }
                    pPrefix = (Prefix*) (pPrefix->d.pPostfix + 1);
                }
            }
        }
    }
    else
        OutputDebugStringA("No memory leak:\n");
}

bool MemPool::ArePagesAllClear()
{
    for (MemPageHeader *p = m_pFirstPage; p != NULL; p = p->d.pNext)
    {
        if (p->d.pLast != (char*) p + sizeof(MemPageHeader))
            return false;
    }
    return true;
}

bool MemPool::VerifyHeapPointer(void* pMem)
{
    bool bOk = false;
    if (IsPtrOk(pMem))
    {
        Prefix *pPrefix = (Prefix*) pMem - 1;
        if (pPrefix->d.pPostfix->pPrefix == pPrefix) 
            bOk = true;
    }

    return (bOk);
}

bool MemPool::IsPtrOk(void* pMem)
{
    return ((pMem) && (((INT_PTR) pMem & (ALIGNMENT - 1)) == 0));
}

void MemPool::RenderDesc(Prefix* pPrefix, char* pBuffer, int nBufferLen)
{
    sprintf_s(pBuffer, nBufferLen, "%08lx ", (DWORD_PTR) pPrefix);
    if (pPrefix->d.szFileName[0])
        sprintf_s(pBuffer + strlen(pBuffer), nBufferLen - strlen(pBuffer), "%s %4ld\n", pPrefix->d.szFileName, pPrefix->d.nLineNumber);  // 输出对应文件名和行数
}
C++内存池的管理
Linuxhus的博客
04-26 693
概述 在c/c++中，内存分配（如malloc或new）会使用很多时间。 一个程序会随着长时间的运行和内存的申请释放而变得越来越慢，内存也会随着时间逐渐碎片化。特别是高频率的进行小内存申请释放，此问题变得尤其严重。 相关视频讲解： 你或许不知道高性能服务器为什么需要内存池？内存如何分配？ 如何设计内存 ？ 150行代码，手写线程池 Linux后端开发网络底层原理知识学习提升，完善技术栈，内容知识点包括Linux，Nginx，ZeroMQ，MySQL，Redis，线程池，MongoDB，ZK，L.
一个C++的内存池和内存管理的实现（一）
qiyao_2000的专栏
04-17 2905
用C++编写高效稳定的软件，有效的内存管理通常是绕不开的一个题目，尤其是对于复杂庞大的商业软件。
常见C++内存池技术
jfkidear的专栏
06-29 1071
总结下常见的C++内存池，以备以后查询。 应该说没有一个内存池适合所有的情况， 根据不同的需求选择正确的内存池才是正道. （1）最简单的固定大小缓冲池     适用于频繁分配和释放固定大小对象的情况， 关于这个内存池，我这里总结过：一个高效的内存池实现 （2）dlmalloc       应该来说相当优秀的内存池， 支持大对象和小对象，并且已被广泛使用。到这里下载：ftp
C++内存管理 --- 内存池
HUGOPIGS的博客
05-26 454
本文讲述了内存池的三种实现方式。
一个跨平台的内存池管理
02-03
一个跨平台的内存管理，可用于多线程消息队列处理等。
一个C++内存池实现
12-13
总的来说，C++内存池的实现是一个涉及内存管理、并发控制和性能优化的复杂任务。通过对内存池的持续改进和优化，可以显著提升程序的运行效率，特别是在需要大量频繁分配和释放小块内存的场景下。
c++内存管理--简单的内存池实现
m0_64396392的博客
09-02 709
内存管理学习--实现简单内存池
c/c++实现高并发内存池
最新发布
01-25
本文介绍的项目是一个基于C/C++语言实现的高并发内存池，其设计理念和技术实现具有高度的实践价值和理论深度。 项目的核心思想是借鉴了谷歌的tcmalloc（Thread-Caching Malloc）内存分配器的设计原理，采用了三级...
c++高性能内存池.rar
03-27
std::allocator 是 C++标准库中提供的默认分配器，他的特点就在于我们在 使用 new 来申请内存构造新对象的时候，势必要调用类对象的默认构造函数 ...所以为了让代码直接可用，我们同样应该在内存池中设计同样的接口：
C++内存管理--详谈
locahuang的博客
07-23 2198
1、简述 内存管理是C++最令人切齿痛恨的问题，也是C++最有争议的问题，C++高手从中获得了更好的性能，更大的自由，C++菜鸟的收获则是一遍一遍的检查代码和对C++的痛恨，但内存管理在C++中无处不在，内存泄漏几乎在每个C++程序中都会发生，因此要想成为C++高手，内存管理一关是必须要过的，除非放弃C++，转到Java或者.NET，他们的内存管理基本是自动的，当然你也放弃了自由和对内存的支配权，还放弃了C++超绝的性能。本期专题将从内存管理、内存泄漏、内存回收这三个方面来探讨C++内存管理问题。 ..
C++内存池
sinat_31608641的博客
12-14 2934
内存池
c++内存池实现
热门推荐
neustar1的专栏
04-19 1万+
利用C/C++开发大型应用程序中，内存的管理与分配是一个需要认真考虑的部分。 本文描述了内存池设计原理并给出内存池的实现代码，代码支持Windows和Linux，多线程安全。 内存池设计过程中需要考虑好内存的分配与释放问题，其实也就是空间和时间的矛盾。 有的内存池设计得很巧妙，内存分配与需求相当，但是会浪费过多的时间去查找分配与释放，这就得不偿失； 实际使用中，我们更多的是关心内存分配的速
C++内存池(附源码)
ConstCpp的博客
05-13 5349
C++内存池 （附源码）
STL学习——STL中的内存池管理技术
千里之行，始于足下
08-18 1万+
当我们new一个对象时，实际做了两件事情：（1）使用malloc申请了一块内存。（2）执行构造函数。
C++内存池的简单原理及实现
踏莎行的博客
05-05 1万+
为什么要用内存池 C++程序默认的内存管理（new，delete，malloc，free）会频繁地在堆上分配和释放内存，导致性能的损失，产生大量的内存碎片，降低内存的利用率。默认的内存管理因为被设计的比较通用，所以在性能上并不能做到极致。 因此，很多时候需要根据业务需求设计专用内存管理器，便于针对特定数据结构和使用场合的内存管理，比如：内存池。 内存池原理 内存池的思想是，在真正使用内存之前，预先...
C/C++内存管理之内存池
Bartle的专栏
03-28 2836
C++内存管理一直是我比较困惑的问题。俗话说初生牛犊不怕虎，做点啥都new一个，然后delete一个。根本不知道底层会有怎么样的运行机制，慢慢地学习才知道以前学习中有一些东西是不可能在工业中应用的。所以想开辟一个坑为C++的内存管理机制。也希望通过这篇能够对C++内存管理机制有一个更加深刻全新的认识吧。New、delete篇在C++中已经将new 和 delete 认定为运算符。我们不用关心是如何进
C++ 内存池实现 并管理内存池（支持多线程）
时间溜走了的博客
06-01 844
Alloctor.h: #ifndef _ALLOCTOR_H_ #define _ALLOCTOR_H_ void* operator new(size_t size); void operator delete(void* p); void* operator new[](size_t size); void operator delete[](void* p); void* mem_alloc(size_t size); void mem_free(void* p); #endif .
C++实现：简易内存池管理
本示例代码展示了如何在C++中实现一个基础的内存池。首先，我们看到两个关键的数据结构：`MemStr` 和 `MemList`。 `MemStr` 结构体用于表示内存池中的内存块，包含以下字段： 1. `InUse`：一个整型变量，用来标记...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值