自学教程：C++ HeapCreate函数代码示例

int _tmain(int argc, _TCHAR* argv[]){	HANDLE hHeap = HeapCreate(HEAP_NO_SERIALIZE, PAGE_SIZE*10, PAGE_SIZE*100);	int* pArr = (int* ) HeapAlloc(hHeap, 0, sizeof(int) * 30);		for(int i = 0 ; i < 10 ; ++i)	{		if(i % 5 == 0)			printf_s("/n");		pArr[i] = (i + 1) * 100;	}	for(int i = 0 ; i < 30 ; ++i)	{		if(i % 5 == 0)		printf_s("/n");		printf_s("%d ", pArr[i]);	}	HeapFree(hHeap, 0, pArr);	HeapDestroy(hHeap);		getchar();	return 0;}

int main(int argc, char *argv[]){	void *test;	HGLOBAL hgtest;	HLOCAL hltest;	HANDLE heapcreate;	LPVOID hptest;	//LPVOID hvtest;	test = malloc(100);	memset(test,'a',100);	zfree(test);	hgtest = GlobalAlloc(GMEM_FIXED,100);	memset(hgtest,'a',100);	zGlobalFree(hgtest);	hltest = LocalAlloc(LMEM_FIXED,100);	memset(hltest,'a',100);	zLocalFree(hltest);	heapcreate = HeapCreate(0,100,100);	hptest = HeapAlloc(heapcreate,HEAP_ZERO_MEMORY,100);	memset(hptest,'a',100);	zHeapFree(heapcreate,0,hptest);	HeapDestroy(heapcreate);	/* yet to implement 	hvtest = VirtualAlloc(NULL,100,MEM_COMMIT,PAGE_READWRITE);	memset(hvtest,'a',100);	zVirtualFree(hvtest,100,MEM_RELEASE);	return 0;	*/}

BOOLLongBinary::SetBinarySize(DWORD sizeNew, void* lpDataCopy){	if (m_hMemory == NULL){ // Allocate		m_pBuffer = NULL;		if (sizeNew == 0)			return TRUE;		m_hMemory = HeapCreate(0L, sizeNew, 0L);		ASSERT(m_hMemory);		m_pBuffer = HeapAlloc(m_hMemory, 0L, sizeNew);		m_dwSize = sizeNew;	}	else{ // Reallocate		if (sizeNew > m_dwSize){			// Allocate or realocate memory . #####			m_pBuffer = HeapReAlloc(m_hMemory, 0L, m_pBuffer, sizeNew);			m_dwSize = sizeNew;		}		else			if (sizeNew == 0){				HeapFree(m_hMemory, 0L, m_pBuffer);				HeapDestroy(m_hMemory);				m_pBuffer = NULL;				m_hMemory = NULL;				m_dwSize = 0;			}		}	if( lpDataCopy != NULL && m_hMemory ){		memcpy(m_pBuffer, lpDataCopy, sizeNew);		}	return TRUE;	}

BOOL CHeapAllocator::Initialize(SIZE_T dwInitSize){    Unitialize();    m_hHeap = HeapCreate(0,dwInitSize,0);	// Jie JIAN changed @ 2007-12-28	// use LFH if possible	typedef BOOL (WINAPI *PFN_HEAPSETINFORMATION)(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T);		HMODULE hKernel32 = LoadLibraryW( L"kernel32.dll" );	if ( NULL != hKernel32 )	{		PFN_HEAPSETINFORMATION pfnHeapSetInformation = 			reinterpret_cast<PFN_HEAPSETINFORMATION>(			GetProcAddress(hKernel32, "HeapSetInformation")			);		if ( NULL != pfnHeapSetInformation )		{			ULONG ulHeapInformation = 2;			(*pfnHeapSetInformation)( m_hHeap,									  HeapCompatibilityInformation,									  &ulHeapInformation,									  sizeof(ULONG) );		}		FreeLibrary(hKernel32);	}    return TRUE;}

// TODO: I should probably move all initalization inside the thread// We should minimize the amount of work done in DLL_PROCESS_ATTACH as per// http://blogs.msdn.com/b/oleglv/archive/2003/10/24/56141.aspxstatic BOOL ProcessAttach(){    lf("memtrace.dll: ProcessAttach()");    if (!OpenPipe()) {        lf("memtrace.dll: couldn't open pipe");        return FALSE;    } else {        lf("memtrace.dll: opened pipe");    }    gHeap = HeapCreate(0, 0, 0);    if (!gHeap) {        lf("memtrace.dll: failed to create heap");        return FALSE;    }    InitializeCriticalSection(&gMemMutex);    gSendThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);    if (!gSendThreadEvent) {        lf("memtrace.dll: couldn't create gSendThreadEvent");        return FALSE;    }    gSendThread = CreateThread(NULL, 0, DataSendThreadProc, NULL, 0, 0);    if (!gSendThread) {        lf("memtrace.dll: couldn't create gSendThread");        return FALSE;    }    InstallHooks();    return TRUE;}

/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */tb_bool_t tb_native_memory_init(){       // enter    tb_spinlock_enter_without_profiler(&g_lock);    // done    tb_bool_t ok = tb_false;    do    {        // have been inited?        tb_check_break_state(!g_heap, ok, tb_true);        // make heap        g_heap = (tb_handle_t)HeapCreate(0, 0, 0);        tb_check_break(g_heap);        // ok        ok = tb_true;    } while (0);    // leave    tb_spinlock_leave(&g_lock);    // ok?    return ok;}

inline static void _win32_initHeap( void ){    g_privateHeap = HeapCreate( 0, 0, 0 );    unsigned int info = 0;    HeapSetInformation( g_privateHeap, HeapCompatibilityInformation, &info, sizeof(info) );}

void PatchMW2_StringList(){	slHashMap.set_empty_key("*DUMMYDUMMY*");	slHashMap.set_deleted_key("*DUMMYDUMM*");	call(0x4D2280, SL_Init, PATCH_JUMP);	call(0x436B40, SL_GetStringOfSize, PATCH_JUMP);	call(0x4EC1D0, SL_ConvertToString_, PATCH_JUMP);	call(0x61BCB0, FindStringOfSize, PATCH_JUMP);	call(0x469D80, SL_ConvertFromString, PATCH_JUMP);	call(0x4D9B00, SL_AddRefToString, PATCH_JUMP);	call(0x4F1500, SL_RemoveRefToStringOfSize, PATCH_JUMP);	call(0x47CD70, SL_RemoveRefToString, PATCH_JUMP);	call(0x417730, Scr_SetString, PATCH_JUMP);	call(0x4401E0, SL_GetStringLen, PATCH_JUMP);	call(0x40C050, SL_TransferRefToUser, PATCH_JUMP);	call(0x4B4310, SL_AddUser, PATCH_JUMP);	call(0x430510, SL_ConvertToLowercase, PATCH_JUMP);	call(0x4F46D0, SL_ShutdownSystem, PATCH_JUMP);	call(0x4A44A0, SL_TransferSystem, PATCH_JUMP);	stringHeap = HeapCreate(0, 1024 * 1024, 0);	// path_node_constant_t marking function; has some terrible string references	*(BYTE*)0x4F74B0 = 0xC3;}

/*! This function has to be called before using any other    function of hpgs. It defines the path, where additional    files such as the truetype files for HPGL files or plugins    are stored.    Truetype fonts are searched in the path <prefix>/share/hpgs    The path is internally duplicated using /c strdup.*/void hpgs_init(const char *path){  int l;  hpgs_reader_prefix = strdup(path);  if (!hpgs_reader_prefix) return;  // strip off trailing directory separators.    l = strlen(hpgs_reader_prefix);  if (l && hpgs_reader_prefix[l-1] == HPGS_PATH_SEPARATOR)    hpgs_reader_prefix[l-1] = '/0';#ifdef WIN32  hHeap = HeapCreate(0,4096,128*1024);  tls_handle = TlsAlloc();#else  pthread_key_create (&key,free);#endif#ifdef HPGS_HAVE_GETTEXT  hpgs_i18n_init();#endif  hpgs_font_init();}

CLrpHeap::CLrpHeap() : m_heap(HeapCreate(0, 0, 0)){	if (nullptr == m_heap)	{		throw runtime_error("Couldn't create a new memory heap");	}}

//-------------------------------------------------------------------------MH_STATUS WINAPI MH_Initialize(VOID){    MH_STATUS status = MH_OK;    EnterSpinLock();    if (g_hHeap == NULL)    {        g_hHeap = HeapCreate(0, 0, 0);        if (g_hHeap != NULL)        {            // Initialize the internal function buffer.            InitializeBuffer();        }        else        {            status = MH_ERROR_MEMORY_ALLOC;        }    }    else    {        status = MH_ERROR_ALREADY_INITIALIZED;    }    LeaveSpinLock();    return status;}

HANDLE get_tls_heap(){	if (local_heap_tls == 0)	{		local_heap_tls = TlsAlloc();		if (local_heap_tls == 0)		{			return (NULL);		}	}	void* tls_val = TlsGetValue(local_heap_tls);	if (tls_val == NULL)	{		HANDLE heap = HeapCreate(HEAP_NO_SERIALIZE, 0, 0);		if (heap == 0)		{			return (NULL);		}		tls_val = (void*)heap;		TlsSetValue(local_heap_tls, tls_val);	}	return (HANDLE)tls_val;}

int InitModuleNames(void){	struct DBModuleName *dbmn;	DWORD ofsThis;	int nameLen;	char *mod;	hModHeap=HeapCreate(0,0,0);	lMods.sortFunc=ModCompare;	lMods.increment=50;	lOfs.sortFunc=OfsCompare;	lOfs.increment=50;	ofsThis=dbHeader.ofsFirstModuleName;	dbmn=(struct DBModuleName*)DBRead(ofsThis,sizeof(struct DBModuleName),NULL);	while(ofsThis) {		if(dbmn->signature!=DBMODULENAME_SIGNATURE) DatabaseCorruption(NULL);		nameLen=dbmn->cbName;		mod = (char*)HeapAlloc(hModHeap,0,nameLen+1);		CopyMemory(mod,DBRead(ofsThis+offsetof(struct DBModuleName,name),nameLen,NULL),nameLen);		mod[nameLen] = 0;		AddToList(mod, nameLen, ofsThis);		ofsThis=dbmn->ofsNext;		dbmn=(struct DBModuleName*)DBRead(ofsThis,sizeof(struct DBModuleName),NULL);	}	CreateServiceFunction(MS_DB_MODULES_ENUM,EnumModuleNames);	return 0;}

BOOL WinAPIOverride32Init(HINSTANCE hInst) {	TCHAR psz[MAX_PATH+32];	TCHAR pszPID[32];	SYSTEM_INFO siSysInfo;	DisableThreadLibraryCalls(hInst);	dwCurrentProcessID = GetCurrentProcessId();	wsprintf(pszPID, "0x%X", dwCurrentProcessID);	lstrcpy(psz, APIOVERRIDE_MUTEX);	lstrcat(psz, pszPID);	pSingleInstance = new CSingleInstance(psz);	if (pSingleInstance->IsAnotherInstanceRunning()) {		delete pSingleInstance;		return FALSE;	}	GetSystemInfo(&siSysInfo); 	dwSystemPageSize = siSysInfo.dwPageSize;	ApiOverrideHeap = HeapCreate(HEAP_CREATE_ENABLE_EXECUTE | HEAP_GROWABLE, dwSystemPageSize, 0);	pLinkListAPIInfos = new CLinkList(sizeof(API_INFO));	pLinkListAPIInfos->SetHeap(ApiOverrideHeap);	return TRUE;}

	Thunk32Base::Thunk32Base()	{		// Double checked locking, guaranteed by Acquire/Release-semantics in Microsoft's		// volatile-implementation.		if(bytecodeHeap == NULL)		{			hMutex = CreateMutex(NULL, TRUE, NULL);			while (hMutex == (HANDLE)NULL || hMutex == (HANDLE)ERROR_ALREADY_EXISTS || hMutex == (HANDLE)ERROR_ACCESS_DENIED) {				Sleep(1000);			}			if(bytecodeHeap == NULL)			{				bytecodeHeap = HeapCreate(HEAP_CREATE_ENABLE_EXECUTE, 0, 0);				if(bytecodeHeap == NULL)				{					throw std::exception("Heap creation failed!");				}				// Schedule the heap to be destroyed when the application terminates.				// Until then, it will manage its own size.				atexit(cleanupHeap);			}		}		bytecode = reinterpret_cast<Bytecode*>(HeapAlloc(bytecodeHeap, 0, sizeof(Bytecode)));		if(bytecode == NULL) 		{			throw std::exception("Bytecode allocation failed!");		}		new (bytecode) Bytecode;	}

//------------------------------------------------------------------------------void CvDllGameContext::InitializeSingleton(){	if(s_pSingleton == NULL)	{		FAssert(s_hHeap == INVALID_HANDLE_VALUE);		s_hHeap = HeapCreate(0, 0, 0);		//		// Enable the low-fragmentation heap (LFH). Starting with Windows Vista,		// the LFH is enabled by default but this call does not cause an error.		//		ULONG HeapInformation = 2;	//Low Fragmentation Heap		HeapSetInformation(s_hHeap,		                   HeapCompatibilityInformation,		                   &HeapInformation,		                   sizeof(HeapInformation));	}	s_pSingleton = FNEW(CvDllGameContext(), c_eCiv5GameplayDLL, 0);#if defined(CUSTOM_MODS_H)	CUSTOMLOG("%s - Startup (Version %u%s - Build %s %s%s)", MOD_DLL_NAME, MOD_DLL_VERSION_NUMBER, MOD_DLL_VERSION_STATUS, __DATE__, __TIME__, MOD_DLL_CUSTOM_BUILD_NAME);#if defined(MOD_GLOBAL_MAX_MAJOR_CIVS)	CUSTOMLOG(" - supporting %i major civilizations", MAX_MAJOR_CIVS);#endif#endif}

bool SaveDump(string fileName, DWORD ep){	strCurEIP = ep;	//OPENFILENAME ofn;	HANDLE hHeap, hFile;	PIMAGE_DOS_HEADER idosh;	PIMAGE_NT_HEADERS ipeh;	PIMAGE_SECTION_HEADER isech;	LPBYTE lpDumpData;	DWORD dwFrom,dwSize,dwAccBytes;	unsigned int i;	dwFrom = PEFileInfo.dwImageBase;	dwSize = PEFileInfo.dwSizeOfImage;	hHeap = HeapCreate(HEAP_NO_SERIALIZE,1,0);	lpDumpData = (LPBYTE)HeapAlloc(hHeap,HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY,dwSize);	dwSize = Readmemory(lpDumpData,dwFrom,dwSize,MM_RESTORE);	idosh = (PIMAGE_DOS_HEADER)lpDumpData;	if(idosh->e_magic != IMAGE_DOS_SIGNATURE) 	{		MessageBox(0, "DUMP: 错误的DOS头（MZ）!!",PNAME,MB_OK | MB_ICONEXCLAMATION);		HeapFree(hHeap,HEAP_NO_SERIALIZE,lpDumpData);		return false;	}	ipeh = (PIMAGE_NT_HEADERS)(lpDumpData + idosh->e_lfanew);	if(ipeh->Signature != IMAGE_NT_SIGNATURE) 	{		MessageBox(0, "DUMP: 错误的PE标志头!!",PNAME,MB_OK | MB_ICONEXCLAMATION);		HeapFree(hHeap,HEAP_NO_SERIALIZE,lpDumpData);		return false;	}	ipeh->FileHeader.NumberOfSections        = PEFileInfo.woNumOfSect;	ipeh->OptionalHeader.ImageBase           = PEFileInfo.dwImageBase;	ipeh->OptionalHeader.SizeOfImage         = PEFileInfo.dwSizeOfImage;	ipeh->OptionalHeader.BaseOfCode          = PEFileInfo.dwBaseOfCode;	ipeh->OptionalHeader.BaseOfData          = PEFileInfo.dwBaseOfData;	ipeh->OptionalHeader.AddressOfEntryPoint = (strCurEIP - PEFileInfo.dwImageBase) ;	isech = IMAGE_FIRST_SECTION(ipeh);	if(FixSect) {		for(i=0; i<(int)PEFileInfo.woNumOfSect; i++) 		{			strcpy((char *)(isech+i)->Name,(char *)(lpSectInfo+i)->byName);			(isech+i)->Misc.VirtualSize = (lpSectInfo+i)->dwVSize;			(isech+i)->VirtualAddress   = (lpSectInfo+i)->dwVOffset;			(isech+i)->SizeOfRawData    = (lpSectInfo+i)->dwVSize;			(isech+i)->PointerToRawData = (lpSectInfo+i)->dwVOffset;			(isech+i)->Characteristics  = (lpSectInfo+i)->dwCharacteristics;		}	}	strcpy( szFileName, fileName.c_str() );	hFile = CreateFile(szFileName, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);	if(hFile != INVALID_HANDLE_VALUE) 	{		SetFilePointer(hFile, 0, 0, FILE_BEGIN);		WriteFile(hFile, lpDumpData, dwSize, &dwAccBytes, NULL);		CloseHandle(hFile);	}	HeapFree(hHeap,HEAP_NO_SERIALIZE,lpDumpData);	return true;}

VOIDMmInitializeHeap(PVOID PageLookupTable){    TRACE("MmInitializeHeap()/n");    /* Create the default heap */    FrLdrDefaultHeap = HeapCreate(DEFAULT_HEAP_SIZE, LoaderOsloaderHeap);    ASSERT(FrLdrDefaultHeap);    /* Create a temporary heap */    FrLdrTempHeap = HeapCreate(TEMP_HEAP_SIZE, LoaderFirmwareTemporary);    ASSERT(FrLdrTempHeap);    TRACE("MmInitializeHeap() done, default heap %p, temp heap %p/n",          FrLdrDefaultHeap, FrLdrTempHeap);}

void *CMemAlloc::Create(int ElSize,int NumEls,DWORD HeapFlags){void *pAllocd;m_LastErr = 0;if(ElSize < 1)			// make the initial allocation worth the exercise	ElSize = 1;if((NumEls * ElSize) < 1024)	NumEls = (1024/ElSize) + 1;if(m_hHeap == NULL)		// create heap, or reuse if one already created	{	if((m_hHeap = HeapCreate(HeapFlags,ElSize * NumEls,0))==NULL)		{		m_LastErr = GetLastError();		return(NULL);		}	pAllocd = HeapAlloc(m_hHeap,HeapFlags,ElSize*NumEls);	}else	pAllocd = HeapReAlloc(m_hHeap,0,m_pAllocd,ElSize*NumEls);if(pAllocd != NULL)	{	m_ElSize = ElSize;	m_NumEls = NumEls;	m_pAllocd = pAllocd;	}else	m_LastErr = GetLastError();return(pAllocd);}

////////////////////////////////////////////////////////////////////////// DllMain -- OCX Main Entry////extern "C" BOOL APIENTRY DllMain(HINSTANCE hDllHandle, DWORD dwReason, LPVOID /*lpReserved*/){	switch (dwReason)	{	case DLL_PROCESS_ATTACH:		v_hModule = hDllHandle;        v_hPrivateHeap = HeapCreate(0, 0x1000, 0);		v_icoOffDocIcon = (HICON)LoadImage(hDllHandle, MAKEINTRESOURCE(IDI_SMALLOFFDOC), IMAGE_ICON, 16, 16, 0);		{			DWORD dwVersion = GetVersion();			v_fUnicodeAPI = ((dwVersion & 0x80000000) == 0);			v_fWindows2KPlus = ((v_fUnicodeAPI) && (LOBYTE(LOWORD(dwVersion)) > 4));		}		InitializeCriticalSection(&v_csecThreadSynch);		DisableThreadLibraryCalls(hDllHandle);		break;	case DLL_PROCESS_DETACH:		if (v_icoOffDocIcon) DeleteObject(v_icoOffDocIcon);        if (v_hPrivateHeap) HeapDestroy(v_hPrivateHeap);        DeleteCriticalSection(&v_csecThreadSynch);		break;	}	return TRUE;}

/***************************************************************************** * DllMain() ***************************************************************************** * DLL entry point. */BOOL WINAPIDllMain(    IN      HINSTANCE   Instance,    IN      ULONG       Reason,    IN      PVOID       Reserved){	BOOL result = TRUE;    switch (Reason)    {        case DLL_PROCESS_ATTACH:        {            hDllInstance = Instance;            hDllHeap = HeapCreate(0, 0x10000, 0);			DisableThreadLibraryCalls(hDllInstance);        }        break;        case DLL_PROCESS_DETACH:        {            if (hDllHeap) HeapDestroy(hDllHeap);        }        break;    }    return result;}

void _createHeap_wxString(){	if( win32_string_heap == INVALID_HANDLE_VALUE )	{		//wxASSERT( win32_string_heap_refcount == 0 );		win32_string_heap = HeapCreate( 0, 0x200000, 0 );	}}

CMemoryPool::CMemoryPool(){	m_heap = HeapCreate(0, 0, 0);	if (nullptr == m_heap)	{		throw runtime_error("Can not create a new memory heap");	}}

 CSimpleWndHelper::CSimpleWndHelper(HINSTANCE hInst,LPCTSTR pszClassName)     :m_hInst(hInst)     ,m_sharePtr(NULL) {     InitializeCriticalSection(&m_cs);     m_hHeap=HeapCreate(HEAP_CREATE_ENABLE_EXECUTE,0,0);     m_atom=CSimpleWnd::RegisterSimpleWnd(hInst,pszClassName); }

void _createHeap_wxObject(){	if( win32_object_heap == INVALID_HANDLE_VALUE )	{		//wxASSERT( win32_object_heap_refcount == 0 );		win32_object_heap = HeapCreate( 0, 0x200000, 0 );	}}

Thread NewThread(void){	 	HANDLE ThreadHeap = HeapCreate(0, 0, 1024);    Thread thread = (Thread) HeapAlloc(ThreadHeap, HEAP_ZERO_MEMORY, sizeof(ThreadClass));		thread->THREADSTACK = 1024;	thread->ThreadHeap = ThreadHeap;	return thread;}

HANDLE STDMETHODCALLTYPE UtilExecutionEngine::ClrHeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize) {#ifdef FEATURE_PAL    return NULL;#else    return HeapCreate(flOptions, dwInitialSize, dwMaximumSize);#endif}

int yr_heap_alloc(void){  hHeap = HeapCreate(0, 0x8000, 0);  if (hHeap == NULL)    return ERROR_INTERNAL_FATAL_ERROR;  return ERROR_SUCCESS;}