Private Heap 是 Windows 提供的一种内存内存机制，对于那些需要频繁分配和释放动态内存的应用程序来说，Private Heap 是提高应用程序性能的一大法宝，使用它能降低 new / malloc 的调用排队竞争以及内存空洞。Private Heap 的原理及应用的资料很多，这里就不一一介绍了，常用的 Private Heap API 有以下几个，具体介绍请参考帮助文档：
HeapCreate(); HeapDestroy(); HeapAlloc(); HeapReAlloc(); HeapSize(); HeapFree(); HeapCompact();
由于是 C 风格的 API，使用起来比较繁琐，因此本座在闲暇之余用 C++ 对这些 API 进行了封装，主要包括两个类：
- CPrivateHeap：自动创建和销毁进程私有堆，每一个该类的对象都代表一个私有堆，所以该类对象的特点是: 一般生命周期都比较长，通常作为全局对象, 其他类的静态成员对象或者一些长生命周期类对象的成员。
- CPrivateHeapBuffer<T>：在私有堆中自动分配和释放指定大小的内存，一般用于在函数体内分配和释放局部作用域的堆内存，从而避免对 CPrivateHeap::Alloc() 和 CPrivateHeap::Free() 的调用。
#pragma once class CPrivateHeap { public: enum EnCreateOptions { CO_DEFAULT = 0, CO_NO_SERIALIZE = HEAP_NO_SERIALIZE, CO_GENERATE_EXCEPTIONS = HEAP_GENERATE_EXCEPTIONS, CO_NOSERIALIZE_GENERATEEXCEPTIONS = HEAP_NO_SERIALIZE | HEAP_GENERATE_EXCEPTIONS }; enum EnAllocOptions { AO_DEFAULT = 0, AO_ZERO_MEMORY = HEAP_ZERO_MEMORY, AO_NO_SERIALIZE = HEAP_NO_SERIALIZE, AO_GENERATE_EXCEPTIONS = HEAP_GENERATE_EXCEPTIONS, AO_ZEROMEMORY_NOSERIALIZE = HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE, AO_ZEROMEMORY_GENERATEEXCEPTIONS = HEAP_ZERO_MEMORY | HEAP_GENERATE_EXCEPTIONS, AO_NOSERIALIZE_GENERATESEXCEPTIONS = HEAP_NO_SERIALIZE | HEAP_GENERATE_EXCEPTIONS, AO_ZEROMEMORY_NOSERIALIZE_GENERATESEXCEPTIONS = HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE | HEAP_GENERATE_EXCEPTIONS }; enum EnReAllocOptions { RAO_DEFAULT = 0, RAO_ZERO_MEMORY = HEAP_ZERO_MEMORY, RAO_NO_SERIALIZE = HEAP_NO_SERIALIZE, RAO_GENERATE_EXCEPTIONS = HEAP_GENERATE_EXCEPTIONS, RAO_REALLOC_IN_PLACE_ONLY = HEAP_REALLOC_IN_PLACE_ONLY, RAO_ZEROMEMORY_NOSERIALIZE = HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE, RAO_ZEROMEMORY_GENERATEEXCEPTIONS = HEAP_ZERO_MEMORY | HEAP_GENERATE_EXCEPTIONS, RAO_ZEROMEMORY_REALLOCINPLACEONLY = HEAP_ZERO_MEMORY | HEAP_REALLOC_IN_PLACE_ONLY, RAO_NOSERIALIZE_GENERATESEXCEPTIONS = HEAP_NO_SERIALIZE | HEAP_GENERATE_EXCEPTIONS, RAO_NOSERIALIZE_REALLOCINPLACEONLY = HEAP_NO_SERIALIZE | HEAP_REALLOC_IN_PLACE_ONLY, RAO_GENERATESEXCEPTIONS_REALLOCINPLACEONLY = HEAP_GENERATE_EXCEPTIONS | HEAP_REALLOC_IN_PLACE_ONLY, RAO_ZEROMEMORY_NOSERIALIZE_GENERATESEXCEPTIONS = HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE | HEAP_GENERATE_EXCEPTIONS, RAO_ZEROMEMORY_NOSERIALIZE_REALLOCINPLACEONLY = HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE | HEAP_REALLOC_IN_PLACE_ONLY, RAO_ZEROMEMORY_GENERATESEXCEPTIONS_REALLOCINPLACEONLY = HEAP_ZERO_MEMORY | HEAP_GENERATE_EXCEPTIONS | HEAP_REALLOC_IN_PLACE_ONLY, RAO_NOSERIALIZE_GENERATESEXCEPTIONS_REALLOCINPLACEONLY = HEAP_NO_SERIALIZE | HEAP_GENERATE_EXCEPTIONS | HEAP_REALLOC_IN_PLACE_ONLY, RAO_ZEROMEMORY_NOSERIALIZE_GENERATESEXCEPTIONS_REALLOCINPLACEONLY = HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE | HEAP_GENERATE_EXCEPTIONS | HEAP_REALLOC_IN_PLACE_ONLY }; enum EnSizeOptions { SO_DEFAULT = 0, SO_NO_SERIALIZE = HEAP_NO_SERIALIZE }; enum EnFreeOptions { FO_DEFAULT = 0, FO_NO_SERIALIZE = HEAP_NO_SERIALIZE }; enum EnCompactOptions { CPO_DEFAULT = 0, CPO_NO_SERIALIZE = HEAP_NO_SERIALIZE }; public: PVOID Alloc(DWORD size, EnAllocOptions options = AO_DEFAULT) {return ::HeapAlloc(m_heap, options, size);} PVOID ReAlloc(PVOID pvmem, DWORD size, EnReAllocOptions options = RAO_DEFAULT) {return ::HeapReAlloc(m_heap, options, pvmem, size);} DWORD Size(PVOID pvmem, EnSizeOptions options = SO_DEFAULT) {return (DWORD)::HeapSize(m_heap, options, pvmem);} BOOL Free(PVOID pvmem, EnFreeOptions options = FO_DEFAULT) {return ::HeapFree(m_heap, options, pvmem);} DWORD Comapct(EnCompactOptions options = CPO_DEFAULT) {return (DWORD)::HeapCompact(m_heap, options);} BOOL IsValid() {return m_heap != NULL;} public: CPrivateHeap(EnCreateOptions options = CO_DEFAULT, DWORD initsize = 0, DWORD maxsize = 0) {m_heap = ::HeapCreate(options, initsize, maxsize);} ~CPrivateHeap() {if(IsValid()) ::HeapDestroy(m_heap);} private: CPrivateHeap(const CPrivateHeap&); CPrivateHeap operator = (const CPrivateHeap&); private: HANDLE m_heap; }; template<class T> class CPrivateHeapBuffer { public: CPrivateHeapBuffer( CPrivateHeap& heap, DWORD size = 0, CPrivateHeap::EnAllocOptions allocoptions = CPrivateHeap::AO_DEFAULT, CPrivateHeap::EnFreeOptions freeoptions = CPrivateHeap::FO_DEFAULT) : m_hpPrivate(heap) , m_opFree(freeoptions) { ASSERT(m_hpPrivate.IsValid()); m_pvMemory = (T*)m_hpPrivate.Alloc(size * sizeof(T), allocoptions); } ~CPrivateHeapBuffer() {m_hpPrivate.Free(m_pvMemory, m_opFree);} T* ReAlloc(DWORD size, CPrivateHeap::EnReAllocOptions options = CPrivateHeap::RAO_DEFAULT) {return m_pvMemory = (T*)m_hpPrivate.ReAlloc(m_pvMemory, size * sizeof(T), options);} DWORD Size(CPrivateHeap::EnSizeOptions options = CPrivateHeap::SO_DEFAULT) {return m_hpPrivate.Size(m_pvMemory, options);} operator T* () const {return m_pvMemory;} private: CPrivateHeapBuffer(const CPrivateHeapBuffer&); CPrivateHeapBuffer operator = (const CPrivateHeapBuffer&); private: CPrivateHeap& m_hpPrivate; T* m_pvMemory; CPrivateHeap::EnFreeOptions m_opFree; }; typedef CPrivateHeapBuffer<BYTE> CPrivateHeapByteBuffer; typedef CPrivateHeapBuffer<TCHAR> CPrivateHeapStrBuffer;
上述代码看起来挺复杂，但使用起来却是异常简单的，请看下面的使用示例：
// 全局可见的 Heap CPrivateHeap g_heap; class MyClass { private: // 与类实例生命周期一致的 Heap CPrivateHeap m_heap; // 仅类内部可见的 Heap static CPrivateHeap sm_heap; public: void test_m_eap() { // 无需显式释放堆内存 CPrivateHeapStrBuffer buff(m_heap, 32); lstrcpy(buff, _T("失败乃成功之母")); DWORD size = buff.Size(); buff.ReAlloc(40 * sizeof(TCHAR)); size = buff.Size(); std::cout << (TCHAR*)buff << ' '; } static void test_sm_eap() { CPrivateHeapStrBuffer buff(sm_heap, 32); lstrcpy(buff, _T("失败乃成功之母")); DWORD size = buff.Size(); buff.ReAlloc(40 * sizeof(TCHAR)); size = buff.Size(); std::cout << (TCHAR*)buff << ' '; } }; void test_g_heap() { // 如果不使用 CPrivateHeapBuffer<T> 来封装堆内存 ASSERT(g_heap.IsValid()); TCHAR* pch = (TCHAR*)g_heap.Alloc(32 * sizeof(TCHAR)); lstrcpy(pch, _T("失败乃成功之母")); DWORD size = g_heap.Size(pch); g_heap.ReAlloc(pch, 40 * sizeof(TCHAR)); size = g_heap.Size(pch); std::cout << pch << ' '; // 需要显式释放堆内存 g_heap.Free(pch); } int _tmain(int argc, _TCHAR* argv[]) { test_g_heap(); MyClass::test_sm_eap(); MyClass c; c.test_m_eap(); return 0; }