一个内存池C++类的实现

最新推荐文章于 2023-10-25 20:37:09 发布
最新推荐文章于 2023-10-25 20:37:09 发布
阅读量941 收藏
点赞数
分类专栏： 开发文档 文章标签： c++ null header delete 游戏 windows

一个内存池C++类的实现

在程序设计领域，程序员经常需要及时动态地产生出一些小型对象，例如读取解析文件时临时需要的缓冲区，动态创建视图时需要的视图对象，游戏程序中怪物，特效，场景物乃至于低级的链表节点等等。如果程序员只是天真地使用new和delete，在经过程序执行中不断反复的分配释放内存后，很快就会使原本完整连续的可用内存块变得支离破碎，这就是内存碎片即Memory Fragmentation问题。更糟的是内存碎片问题往往很难检测出来。

为了尽可能降低内存碎片的状况，并且得到高效的内存管理程序，除了从增加计算机配置，如增加内存条，和从程序的逻辑上着手，如减少读取解析文件时临时需要的缓冲区，减少动态创建视图的次数，减少游戏程序中怪物，特效，场景物出现频度之外，同时还需要从程序的低级层面，即从内存分配的功能面着手改善。

在用户每次new操作从系统索取内存空间时，C++的函数库除了配置所要求的内存块大小以外，还会另外生成一小块额外的内存块以记载相关的资料。对于经常进行产生与销毁的小型对象来说，这样的行为就显得十分浪费而不具效率。如果能够一次性的分配出一大块内存，然后再根据用户的需求传回部分内存块，这样就能改善new操作所产生的额外负担。

在这里，我参考早年微软MSJ期刊的一些资料写出了一个内存池C++类:CMemPool，这个内存池建立在树状的双向链表之上的，其相关结构体定义如下：

  1. //树型内存块分配结构.
  2. typedef struct tagMEMORY_BLOCK  MEMORY_BLOCK, *LPMEMORY_BLOCK;
  3. struct tagMEMORY_BLOCK
  4. {
  5.     DWORD                 dwIndex;
  6.     DWORD                 dwSize;
  7.     LPMEMORY_BLOCK        lpNext;
  8.     LPMEMORY_BLOCK        lpPrev;
  9.     LPBYTE                lpMemory;
  10. };
  12. //内存池标头结构
  13. typedef struct tagHEADER  HEADER, *LPHEADER;
  14. struct tagHEADER
  15. {
  16.     LPMEMORY_BLOCK   lpHead;
  17.     HANDLE           hHeap;
  18. };

好了，我就不再啰嗦了，下面列出CMemPool类的源码，有不对之处，请不吝赐教！~~~

CMemPool类的头文件MemPool.h代码如下：

  1. //=====================================================================
  2. //               内存池类CMemPool的头文件CMemPool.h
  3. //by 一剑(Loomman),QQ:28077188,MSN: Loomman@hotmail.com QQ裙：30515563
  4. //=====================================================================
  5. #ifndef MEMPOOL_H
  6. #define MEMPOOL_H
  8. #define STRICT
  9. #define LEAN_AND_MEAN
  11. #include <windows.h>
  12. #include <assert.h>
  13. #include <stdio.h>
  14. #include <mbstring.h>
  16. //默认内存分配页大小设为8KB
  17. #define     MEMPOOL_BLOCK_SIZE      8192
  19. class CMemPool
  20. {
  21. public:
  23.     CMemPool();
  24.     ~CMemPool();
  26.     BOOL   Initialize();
  27.     VOID   Destroy();
  29.     LPVOID GetAlignedMemory(DWORD dwSize, DWORD dwAlignSize);
  30.     LPSTR  GetDuplicateStringA(LPCSTR szSrc);
  31.     LPWSTR GetDuplicateStringW(LPCWSTR szSrc);
  33.     inline LPVOID GetMemory(DWORD dwSize) 
  34.     {
  35.         return GetAlignedMemory(dwSize, 0);
  36.     }
  38.     inline TCHAR* GetStringBuffer(DWORD dwLen)
  39.     {
  40.         return (TCHAR*)GetAlignedMemory(dwLen * sizeof(TCHAR), 0);
  41.     }
  43.     inline LPSTR GetStringBufferA(DWORD dwLen) 
  44.     {
  45.         return (LPSTR)GetAlignedMemory(dwLen * sizeof(CHAR), sizeof(CHAR));
  46.     }
  48.     inline LPWSTR GetStringBufferW(DWORD dwLen) 
  49.     {
  50.         return (LPWSTR)GetAlignedMemory(dwLen * sizeof(WCHAR), sizeof(WCHAR));
  51.     }
  53.     inline DWORD* GetDwordBuffer()
  54.     {
  55.         return (DWORD*)GetAlignedMemory(sizeof(DWORD), 0);
  56.     }
  58. private:
  59.     BOOL   AddMemory(DWORD dwSize);
  60.     LPVOID handle;
  61. };
  63. #endif //MEMPOOL_H

CMemPool类的实现文件MemPool.cpp代码如下：

  1. //=====================================================================
  2. //               内存池类CMemPool的实现文件CMemPool.cpp
  3. //by 一剑(Loomman),QQ:28077188,MSN: Loomman@hotmail.com QQ裙：30515563
  4. //=====================================================================
  5. #include "MemPool.h"
  7. //树型内存块分配结构.
  8. typedef struct tagMEMORY_BLOCK  MEMORY_BLOCK, *LPMEMORY_BLOCK;
  9. struct tagMEMORY_BLOCK
  10. {
  11.     DWORD                 dwIndex;
  12.     DWORD                 dwSize;
  13.     LPMEMORY_BLOCK        lpNext;
  14.     LPMEMORY_BLOCK        lpPrev;
  15.     LPBYTE                lpMemory;
  16. };
  18. //内存池标头结构
  19. typedef struct tagHEADER  HEADER, *LPHEADER;
  20. struct tagHEADER
  21. {
  22.     LPMEMORY_BLOCK   lpHead;
  23.     HANDLE           hHeap;
  24. };
  26. //内存池对象构造函数
  27. CMemPool::CMemPool()
  28. {
  29.     handle = NULL;
  30. }
  32. //内存池对象析构函数
  33. CMemPool::~CMemPool()
  34. {
  35.     Destroy();
  36. }
  38. //内存池对象初始化，首次分配8KB内存作为内存池
  39. BOOL CMemPool::Initialize()
  40. {
  41.     if( NULL == handle )
  42.     {
  43.         HANDLE  procHeap = GetProcessHeap();
  45.         // 分配内存池的头节点.
  46.         handle = HeapAlloc(procHeap, 0, sizeof(HEADER));
  48.         if (handle) 
  49.         {
  50.             LPHEADER header = (LPHEADER)handle;
  51.             // 分配头节点成功，现在初始化内存池.
  52.             header->lpHead = NULL;
  53.             header->hHeap = procHeap;
  55.             //初次实际分配8KB内存到内存池.
  56.             BOOL  ableToAddMemory = AddMemory(0);
  58.             if (!ableToAddMemory) 
  59.             {
  60.                 //分配内存失败，系统资源瓶颈！
  61.                 HeapFree(header->hHeap, 0, handle);
  62.                 handle = NULL;
  63.             }
  64.         }
  65.     }
  66.     return (handle != NULL);
  67. }
  69. VOID CMemPool::Destroy()
  70. {
  71.     if(handle != NULL)
  72.     {
  73.         LPMEMORY_BLOCK  nextBlock;
  74.         LPMEMORY_BLOCK  blockToFree; 
  75.         LPHEADER        poolHeader = (LPHEADER)handle;
  77.         //遍历链表，进行释放内存操作.
  78.         blockToFree = poolHeader->lpHead;
  80.         while (blockToFree != NULL)
  81.         {
  82.             nextBlock = blockToFree->lpNext;
  83.             HeapFree(poolHeader->hHeap, 0, blockToFree);
  84.             blockToFree = nextBlock;
  85.         }
  87.         //别忘记了，内存池头结点也需要释放.
  88.         HeapFree(poolHeader->hHeap, 0, handle);
  89.         handle = NULL;
  90.     }
  91. }
  93. LPVOID CMemPool::GetAlignedMemory(DWORD dwSize, DWORD dwAlignSize)
  94. {
  95.     assert(handle != NULL);
  97.     BOOL            haveEnoughMemory = TRUE;
  98.     LPVOID          lpMemory         = NULL;
  99.     LPHEADER        poolHeader       = (LPHEADER)handle;
  100.     LPMEMORY_BLOCK  currentBlock;
  101.     DWORD           sizeNeeded;
  102.     DWORD           padLength;
  104.     currentBlock = poolHeader->lpHead;
  106.     // 判断是否需要更多的内存，如果是，则分配之.
  107.     sizeNeeded = dwSize;
  109.     if (currentBlock->dwSize - currentBlock->dwIndex < sizeNeeded + dwAlignSize)
  110.     {
  111.         haveEnoughMemory = AddMemory(sizeNeeded + dwAlignSize);
  112.         currentBlock = poolHeader->lpHead;
  113.     }
  115.     // 现在有了足够的内存，返回它！
  116.     if (haveEnoughMemory)
  117.     {
  118.         if (dwAlignSize)
  119.         {
  120.             padLength = (DWORD)currentBlock + sizeof(MEMORY_BLOCK) + currentBlock->dwIndex;
  121.             currentBlock->dwIndex += (dwAlignSize - (padLength % dwAlignSize)) % dwAlignSize;
  122.         }
  123.         
  124.         //这里得到了内存地址，返回它！
  125.         lpMemory = (LPVOID)&(currentBlock->lpMemory[currentBlock->dwIndex]);
  127.         currentBlock->dwIndex += sizeNeeded;
  128.     }
  130.     return lpMemory;
  131. }
  133. LPSTR CMemPool::GetDuplicateStringA(LPCSTR szSrc)
  134. {
  135.     assert(szSrc);
  137.     DWORD dwBytes = (_mbslen((const unsigned char*)szSrc) + 1) * sizeof(CHAR);
  138.     LPSTR pString = (LPSTR)GetAlignedMemory(dwBytes, sizeof(CHAR));
  140.     if (pString) 
  141.     {
  142.         _mbscpy_s((unsigned char*)pString, dwBytes, (const unsigned char*)szSrc);
  143.     }
  144.     return pString;
  145. }
  147. LPWSTR CMemPool::GetDuplicateStringW(LPCWSTR szSrc)
  148. {
  149.     assert(szSrc);
  151.     DWORD dwBytes = (wcslen(szSrc) + 1) * sizeof(WCHAR);
  152.     LPWSTR pString = (LPWSTR)GetAlignedMemory(dwBytes, sizeof(WCHAR));
  154.     if (pString) 
  155.     {
  156.         wcscpy_s(pString, dwBytes, szSrc);
  157.     }
  158.     return pString;
  159. }
  161. BOOL CMemPool::AddMemory(DWORD dwSize)
  162. {
  163.     LPBYTE           allocedMemory;
  164.     LPMEMORY_BLOCK   newBlock;
  165.     LPHEADER         poolHeader = (LPHEADER)handle;
  166.     DWORD            sizeNeeded;
  168.     assert(poolHeader != NULL);
  170.     // 计算需要分配内存的最小数量，并试图分配之.
  171.     if (dwSize + sizeof(MEMORY_BLOCK) > MEMPOOL_BLOCK_SIZE) 
  172.     {
  173.         sizeNeeded = dwSize + sizeof(MEMORY_BLOCK);
  174.     }
  175.     else 
  176.     {
  177.         sizeNeeded = MEMPOOL_BLOCK_SIZE;
  178.     }
  180.     allocedMemory = (LPBYTE)HeapAlloc(poolHeader->hHeap, 0, sizeNeeded);
  182.     if (allocedMemory) 
  183.     {
  184.         // 使内存块的头部存储一个MEMORY_BLOCK结构.
  185.         newBlock = (LPMEMORY_BLOCK)allocedMemory;
  186.         newBlock->dwSize = sizeNeeded - sizeof(MEMORY_BLOCK);
  187.         newBlock->lpMemory = allocedMemory + sizeof(MEMORY_BLOCK);
  188.         newBlock->dwIndex = 0;
  189.     
  190.         // 把内存块链接到list中.
  191.         if(poolHeader->lpHead) 
  192.         {
  193.             poolHeader->lpHead->lpPrev = newBlock;
  194.         }
  195.         newBlock->lpNext = poolHeader->lpHead;
  196.         newBlock->lpPrev = NULL;
  197.         poolHeader->lpHead = newBlock;
  198.     }
  200.     // 如果allocedMemory 不是 NULL, 则表明我们成功了.
  201.     return allocedMemory != NULL;
  202. }

CMemPool类使用演示程序代码如下：

  1. #include <TCHAR.H>
  2. #include "MemPool.h"
  4. int main()
  5. {
  6.     CMemPool mp;
  7.     assert( mp.Initialize() );
  9.     for(int i = 0; i<100; i++)
  10.     {
  11.         TCHAR* psz = mp.GetStringBuffer(8192);
  12.         _stprintf_s(psz, 8192, TEXT("now i=%d/n"), i);
  13.         _tprintf(psz);
  14.     }
  16.     mp.Destroy();
  17.     return getchar();
  18. }

在其中的

  1. _tprintf(psz);

和
  1. mp.Destroy();

这两行打上断点，调试运行，观察windows任务管理器关于该进程的内存使用量呈明显的规律性增长。最后当执行完

mp.Destroy();后该进程的内存使用量又恢复到未使用内存池时的状态。
实现一个内存池管理的类
鱼思故渊的专栏
04-16 1244
模拟STL中的freelist,有这个思想在内。 union obj { union obj* next; char p[1]; }; class MemoryPool { public: MemoryPool() { union obj* temp; m_
C++实现定长内存池
qq_64446981的博客
05-26 837
在说内存池之前，我们得先了解一下“池化技术”。所谓“池化技术”，就是程序先向系统申请过量的资源，然后自己进行管理，以备不时之需。之所以要申请过量的资源，是因为申请和释放资源都有较大的开销，不如提前申请一些资源放入“池”中，当需要资源时直接从“池”中获取，不需要时就将该资源重新放回“池”中即可。这样使用时就会变得非常快捷，可以大大提高程序的运行效率。在计算机中，有很多使用“池”这种技术的地方，除了内存池之外，还有连接池、线程池、对象池等。
内存池实现类
10-26
多线程和服务器中使用内存池避免内存的频繁new和delete导致系统不稳定。自己实现的一个内存池，带引用计数，线程安全，经过测试，使用内存池后程序稳定性显著提升。
C++内存池(附源码)
wang13342322203的博客
08-09 492
C++内存池(附源码) 前段时间阅读了Nginx的源码，其对内存高效的管理给我留下了深刻的印象，而内存管理的核心便是内存池。于是想自己实现一个C++版本的内存池，这方面当然还是STL的内存池最为经典，所以免不了参悟借鉴。内存池的概念早已经是老生常谈，然而把内存池实现的高效安全仍是个比较艰巨的问题。内存池的原理简单来讲就是一次性的向系统申请大量的内存，之后再有内存请求的时候，如果内存池的内存大小能够...
一个C++内存池实现
12-13
本项目提供了一个C++内存池的实现，包括全局的一级内存池和每个线程独立的二级内存池。这种设计考虑到了多线程环境下的内存分配需求，确保每个线程有其私有的内存池，降低了不同线程间内存分配的冲突，提升了并发...
C++实现高性能内存池.docx
04-29
C++中实现高性能内存池的关键在于设计一个自定义的内存分配器，这个分配器需要提供与标准库中的`std::allocator`类似的接口，但内部实现利用内存池的机制。 在C++中，`std::allocator`是一个通用的内存分配器，它...
c/c++实现高并发内存池
最新发布
01-25
本文介绍的项目是一个基于C/C++语言实现的高并发内存池，其设计理念和技术实现具有高度的实践价值和理论深度。 项目的核心思想是借鉴了谷歌的tcmalloc（Thread-Caching Malloc）内存分配器的设计原理，采用了三级...
c++ 内存池的实现
qq_54662616的博客
03-27 1456
平常我们在使用malloc申请内存时，频繁的申请小块内存会造成内存的浪费，所以可以使用内存池来减少内存的浪费。 memory_pool.h #ifndef MEMORY_POOL #define MEMORY_POOL #include <iostream> #define size 20 #define numsize 10 class freenode { public: char data[size]; struct obj { stru
静态内存池源代码C++编写
08-28
下载时请看下面说明，对写一个动态的内存池很有帮助。 这是一个用C++语言链表的方法实现的一个静态内存池代源码。原理就是先向系统申请一块大内存，然后把这一大块分隔成相等的很多小块，然后在这这些小块的首地址部份放一个结构体，结构体中有一个值是用来标明这一小块是否使用中。在这里存放你要放存的数据就是用结构体首地址加结构体自身长度就得到要放数据的首地址了.具体看代码的实现吧。我说一下动态内存池的写法。那是我给公司写的就不能上传了。结构体和静态内存池的这个差不多一样，只是增加了一个成员用来记录每一节点到大块内存的首地址在到本节点的一个尺寸长度值，做法也是先申请一块大内存。我先从释放说起吧，释放本节点时看自己的相邻节点是不是有释放掉的，如果有则合并掉他们成为一个块，如果碰到相邻的节点是另外的一个大块的话就不用合并了，原因他和自己所在的这一个大块内存上物理地址不是连续，这里一定要记住，释放过程算法怎么去写就看你的了。下面是分配写法要考虑的。在分配一小块内存给高层使用时，如果是分配在尾节点去分配的情况，那好办啊，尾节点如果不够分配了就直接从系统去申请一块大内存，节点连起来在分配，这里有可能会浪费掉一小块以结构体大小的一块内存，如果够分配就直接分配了。如果是在中间节点去分配，这里就要将释放时合并的如果大于现在要分配的就拆开来用，如果拆开剩余的那一部份只有结构体大小就不用在拆开了。这些都是要考虑的东西，优化加快速度就看你自己了.可能看时不些不明白，看静态内存的写法后你就明白了.有时我也要下载其他人共享的东西，所以就一分吧.哈哈~~~~
内存池源码
11-05
一个内存池的实现源码，简单易懂而且高效，我在实际项目中已经使用，效果不错，在原来的基础上，我加入了对多线程的处理。
几种内存池的实现(c/c++ 源码)
07-25
几种 内存池 的实现 (c/c++ 源码)
用c++ 定义一个车(Vehicle)基类，有Run，Stop等成员函数，由此派生出自行车(bicycle)类，汽车(motorcar)
11-03
用c++ 定义一个车(Vehicle)基类，有Run，Stop等成员函数，由此派生出自行车(bicycle)类，汽车(motorcar)类，从bicycle和 motorcar派生出摩托车(motorcycle)类，他们都有Run，Stop等成员函数。编写完整并用主函数测试。体会虚基类的使用
MemoryPool:使用 C++11 的简单内存池实现
06-13
内存池 使用 C++11 的简单内存池实现。 与 Visual Studio 2015、g++4.8 和 clang++3.4 兼容。 一个使用和文档的例子即将到来。
源码分享：C++高性能的内存池实现。内存预分配，非复制构造，全局内存池。
carlclouder的博客
02-10 1274
为了实现面向对象编程，对于的复杂型结构快速构造与释放，写了个内存池管理模板。他特点是允许用户放弃内存池生成对象使用权，而不是执行析构。实现对象的复用。 实现同类型对象内存池的全局华管理。内存块的大小可调。内存池状态可输出显示。 内存预分配。对象构造采用原始构造，非动态申请和复制构造，提高速度。 加锁，实现多线程支持。 通过giveUpOne方法放弃对象使用权，不需要释放对象，实现高度对象复用。 ...
7.3内存池概念、代码实现和详细分析
qq_41543888的博客
10-11 288
1.内存池的概念和实现原理概述 malloc：内存浪费，频繁分配小块内存，则浪费更加显得明显 “内存池”，要解决什么问题？ (1)减少malloc的次数，减少malloc()调用次数就意味着减少对内存的浪费 (2)减少malloc的调用次数，是否能够提高程序运行效率？ 会有一些速度和效率上的提升，但是提升不明显； “内存池的实现原理”： (1)用m...
C++简单实现内存池原理
爪哇盘古
10-25 191
【代码】C++简单实现内存池原理。
内存池实现附c++代码
周春岳的程序人生
01-25 443
摘    要： 内存池 1.避免内存频繁的分配和释放。 2.即便内存的使用者忘记释放内存，那么这些内存也不会丢失，它们仍然保存在内存池中，当内存池被销毁的时候这些内存将自动的被销毁。 3.实现内存动态可变大小分配,打破以往简易内存池固化大小的限制。 MemPool.h #pragma once #include using namespace std; //内存池 class CM
C++内存池设计与实现详解
C++实现内存池需要考虑内存分配策略、内存池的大小、线程安全等问题。通过精心设计和实现，内存池可以优化资源利用，减少内存分配和释放带来的开销。在具体应用时，需要根据实际场景选择合适的内存池实现策略，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值