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

void SetupCRT(const CommandLine& parsed_command_line) {#if defined(OS_WIN)#ifdef _CRTDBG_MAP_ALLOC  _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);  _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);#else  if (!parsed_command_line.HasSwitch(switches::kDisableBreakpad)) {    _CrtSetReportMode(_CRT_ASSERT, 0);  }#endif  // Enable the low fragmentation heap for the CRT heap. The heap is not changed  // if the process is run under the debugger is enabled or if certain gflags  // are set.  bool use_lfh = false;  if (parsed_command_line.HasSwitch(switches::kUseLowFragHeapCrt))    use_lfh = parsed_command_line.GetSwitchValue(switches::kUseLowFragHeapCrt)        != L"false";  if (use_lfh) {    void* crt_heap = reinterpret_cast<void*>(_get_heap_handle());    ULONG enable_lfh = 2;    HeapSetInformation(crt_heap, HeapCompatibilityInformation,                       &enable_lfh, sizeof(enable_lfh));  }#endif}

//used if windows subsystemint WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow){	//notify user if heap is corrupt	HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL,0);	// Enable run-time memory leak check for debug builds.	#if defined(DEBUG) | defined(_DEBUG)		_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );	#endif	MainEngine engine;	//AbstractGame *gamePtr = new Test();	//AbstractGame *gamePtr = new RType();	//AbstractGame *gamePtr = new BouncingBall();	//AbstractGame *gamePtr = new BouncingBalls();	//AbstractGame *gamePtr = new Goniometry();	AbstractGame *gamePtr = new Chainreaction();	//AbstractGame *gamePtr = new SolarSystem();	//AbstractGame *gamePtr = new ButtonTextBoxTestApp();	//AbstractGame *gamePtr = new LineCollision();	//AbstractGame *gamePtr = new FollowMouse();	//AbstractGame *gamePtr = new PolygonTester();	//AbstractGame *gamePtr = new AlteredBeast();	//AbstractGame *gamePtr = new CaveApp();	//AbstractGame *gamePtr = new AudioTester();	engine.SetGame(gamePtr);	if (SUCCEEDED(engine.Initialize()))	{		engine.RunMessageLoop();	}	delete gamePtr;	return 0;}

// Program's main entry pointint APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR lpCmdLine, int nCmdShow){#ifdef _DEBUG	AllocConsole();	HANDLE handle_out = GetStdHandle(STD_OUTPUT_HANDLE);	int hCrt = _open_osfhandle((long) handle_out, _O_TEXT);	FILE* hf_out = _fdopen(hCrt, "w");	setvbuf(hf_out, NULL, _IONBF, 1);	*stdout = *hf_out;	HANDLE handle_in = GetStdHandle(STD_INPUT_HANDLE);	hCrt = _open_osfhandle((long) handle_in, _O_TEXT);	FILE* hf_in = _fdopen(hCrt, "r");	setvbuf(hf_in, NULL, _IONBF, 128);	*stdin = *hf_in;#endif    UNREFERENCED_PARAMETER(hPrevInstance);    SingleFace app;    HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);    return app.Run(hInstance, lpCmdLine, nCmdShow);}

// Provides the application entry point.int WINAPI WinMain(    HINSTANCE /* hInstance */,    HINSTANCE /* hPrevInstance */,    LPSTR /* lpCmdLine */,    int /* nCmdShow */){    // Use HeapSetInformation to specify that the process should    // terminate if the heap manager detects an error in any heap used    // by the process.    // The return value is ignored, because we want to continue running in the    // unlikely event that HeapSetInformation fails.    HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);    if (SUCCEEDED(CoInitialize(NULL)))    {        {            DemoApp app;            if (SUCCEEDED(app.Initialize()))            {                app.RunMessageLoop();            }        }        CoUninitialize();    }    return 0;}

//------------------------------------------------------------------------------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}

	/*	* http://msdn.microsoft.com/en-us/library/windows/desktop/aa366750(v=vs.85).aspx	*/	void CMemorymgt::EnableLFH()	{		// get default heaps		while (true)		{			DWORD lTotalHeapNum = ::GetProcessHeaps(mHeapHandleCount, mHeapHandle.begin());			if (lTotalHeapNum == 0)			{				return;			}			if (lTotalHeapNum != mHeapHandleCount)			{				mHeapHandleCount = lTotalHeapNum;				mHeapHandle.reset(mHeapHandleCount);			}			else 				break;		}				// enable low fragmentation heap		unsigned long lHeapFragValue = 2;		for (int iter = 0; iter < mHeapHandleCount; ++iter)		{			if (!HeapSetInformation(				mHeapHandle[iter],				HeapCompatibilityInformation,				&lHeapFragValue,				sizeof(lHeapFragValue)				))			{			}		}	}

int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR pCmdLine, int nCmdShow){	UNREFERENCED_PARAMETER(nCmdShow);	UNREFERENCED_PARAMETER(pCmdLine);	//notify user if heap is corrupt	HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL,0);	// Enable run-time memory leak check for debug builds.	#if defined(DEBUG) | defined(_DEBUG)		_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );		typedef HRESULT(__stdcall *fPtr)(const IID&, void**); 		HMODULE hDll = LoadLibrary(L"dxgidebug.dll"); 		fPtr DXGIGetDebugInterface = (fPtr)GetProcAddress(hDll, "DXGIGetDebugInterface"); 		IDXGIDebug* pDXGIDebug;		DXGIGetDebugInterface(__uuidof(IDXGIDebug), (void**)&pDXGIDebug);		//_CrtSetBreakAlloc(4039);	#endif	auto pGame = new MainGame();	auto result = pGame->Run(hInstance);	UNREFERENCED_PARAMETER(result);	delete pGame;		return 0;}

int WINAPI WinMain(    HINSTANCE /* hInstance */,    HINSTANCE /* hPrevInstance */,    LPSTR /* lpCmdLine */,    int /* nCmdShow */    ){    // Ignoring the return value because we want to continue running even in the    // unlikely event that HeapSetInformation fails.    HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);    if (SUCCEEDED(CoInitialize(NULL)))    {        {            DemoApp app;            if (SUCCEEDED(app.Initialize()))            {                app.RunMessageLoop();            }        }        CoUninitialize();    }    return 0;}

int WINAPI wWinMain(_In_ HINSTANCE hInstance,	_In_opt_ HINSTANCE hPrevInstance,	_In_ PWSTR lpCmdLine,	_In_ int nCmdShow){	UNREFERENCED_PARAMETER(hPrevInstance);	UNREFERENCED_PARAMETER(lpCmdLine);	if (!CoInitializeSingle::Initialize()){	}	HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);	Metro::MUI::muiController.Init();	_Module.Init(nullptr, hInstance);	MSG msg;	::InitCommonControls();	Metro::MetroWindow iMetroWindow;		RECT rect = { (::GetSystemMetrics(SM_CXSCREEN) - 720) / 2, (::GetSystemMetrics(SM_CYSCREEN) - 450) / 2, (::GetSystemMetrics(SM_CXSCREEN) + 720) / 2, (::GetSystemMetrics(SM_CYSCREEN) + 450) / 2 };	if (iMetroWindow.Create(nullptr, rect, METRO_INTERNAL_WINDOWLNAME, WS_OVERLAPPED | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, WS_EX_ACCEPTFILES) == nullptr)	{		return -1;	}	DWORD dwExit = 0;	iMetroWindow.ShowWindow(nCmdShow);	iMetroWindow.UpdateWindow();	while (GetMessage(&msg, nullptr, 0, 0)>0)	{		TranslateMessage(&msg);		DispatchMessage(&msg);	}	dwExit = iMetroWindow.GetExitCode();	_Module.Term();	return dwExit;}

int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR, int nCmdShow){    HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);    MSG msg;    ZeroMemory(&msg, sizeof(msg));    // Perform application initialization.    if (!InitInstance(hInstance, nCmdShow))    {        NotifyError(NULL, L"Could not initialize the application.",             HRESULT_FROM_WIN32(GetLastError()));        return FALSE;    }    // Main message loop.    while (GetMessage(&msg, NULL, 0, 0))    {        TranslateMessage(&msg);        DispatchMessage(&msg);    }    // Clean up.    if (g_pPlayer)    {        g_pPlayer->Shutdown();        SafeRelease(&g_pPlayer);    }    return 0;}

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

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow){	UNREFERENCED_PARAMETER(hInstance);	UNREFERENCED_PARAMETER(hPrevInstance);	UNREFERENCED_PARAMETER(lpCmdLine);	UNREFERENCED_PARAMETER(nCmdShow);#if defined (DEBUG) | (_DEBUG)	HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);	//Enable run-time memory leak check for debug builds.	//_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);	//_CrtSetBreakAlloc(0)#endif	//Create the engine	//Engine* pEngine = ne Engine();	//Kick of the game	//int result = pEngine->RunLoop();	//Delete the engine	//delete pEngine;	//return result;	return 0;}

static intsubsys_winprocess_initialize(void){#ifndef HeapEnableTerminationOnCorruption#define HeapEnableTerminationOnCorruption 1#endif  /* On heap corruption, just give up; don't try to play along. */  HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);  /* SetProcessDEPPolicy is only supported on 32-bit Windows.   * (On 64-bit Windows it always fails, and some compilers don't like the   * PSETDEP cast.)   * 32-bit Windows defines _WIN32.   * 64-bit Windows defines _WIN32 and _WIN64. */#ifndef _WIN64  /* Call SetProcessDEPPolicy to permanently enable DEP.     The function will not resolve on earlier versions of Windows,     and failure is not dangerous. */  HMODULE hMod = GetModuleHandleA("Kernel32.dll");  if (hMod) {    typedef BOOL (WINAPI *PSETDEP)(DWORD);    PSETDEP setdeppolicy = (PSETDEP)GetProcAddress(hMod,                           "SetProcessDEPPolicy");    if (setdeppolicy) {      /* PROCESS_DEP_ENABLE | PROCESS_DEP_DISABLE_ATL_THUNK_EMULATION */      setdeppolicy(3);    }  }#endif /* !defined(_WIN64) */  return 0;}

bool AL_CALLTYPE alHeapWin32_SetLowFragmentation(void* _this, bool bEnableLowFragmantation){	alHeapWin32i* _data = (alHeapWin32i*)_this;	ULONG HeapFragValue = bEnableLowFragmantation ? 2 : 0;	if (!_data->heap)		return false;	return !!HeapSetInformation(_data->heap, HeapCompatibilityInformation, &HeapFragValue, sizeof(HeapFragValue));}

// Program's main entry pointint APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR lpCmdLine, int nCmdShow){    UNREFERENCED_PARAMETER(hPrevInstance);    MultiFace app;    HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);    return app.Run(hInstance, lpCmdLine, nCmdShow);}

int WINAPI wWinMain(    HINSTANCE hInstance,    HINSTANCE hPrevInstance,    LPWSTR pszCmdLine,    int nCmdShow){    UNREFERENCED_PARAMETER(hPrevInstance);    UNREFERENCED_PARAMETER(pszCmdLine);    UNREFERENCED_PARAMETER(nCmdShow);    HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);    HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);    if (SUCCEEDED(hr))    {        {            DemoApp app;            HWND hWndMain = NULL;            hWndMain = app.Initialize(hInstance);            hr = hWndMain ? S_OK : E_FAIL;            if (SUCCEEDED(hr))            {                BOOL fRet;                MSG msg;                // Load accelerator table                HACCEL haccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDA_ACCEL_TABLE));                if (haccel == NULL)                 {                    hr = E_FAIL;                }                // Main message loop:                while ((fRet = GetMessage(&msg, NULL, 0, 0)) != 0)                {                    if (fRet == -1)                    {                        break;                    }                    else                    {                        if (!TranslateAccelerator(hWndMain, haccel, &msg))                        {                            TranslateMessage(&msg);                            DispatchMessage(&msg);                        }                    }                }            }        }        CoUninitialize();    }    return 0;}

void_gum_memory_init (void){  ULONG heap_frag_value = 2;  _gum_memory_heap = HeapCreate (HEAP_GENERATE_EXCEPTIONS, 0, 0);  HeapSetInformation (_gum_memory_heap, HeapCompatibilityInformation,      &heap_frag_value, sizeof (heap_frag_value));}

AutoDiscoveryServerImpl::AutoDiscoveryServerImpl(const std::string& type, unsigned int port){    HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);    std::ostringstream ss;    ss << port;    DNSServiceErrorType err = RegisterService(&client, "", type.c_str(), "", NULL, ss.str().c_str(), this);    if (!client || err != kDNSServiceErr_NoError) {         OSG_WARN << "AutoDiscoveryImpl :: DNSService call failed " << (long int)err << std::endl;     }}

int WINAPI wWinMain(HINSTANCE /* hInstance */, HINSTANCE /* hPrevInstance */, LPWSTR lpCmdLine, int /* nCmdShow */){	LPWSTR* arg_list;	int arg_num = 0;    // Ignore the return value because we want to continue running even in the    // unlikely event that HeapSetInformation fails.    HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);    if (SUCCEEDED(CoInitialize(NULL)))    {		App *app = new App();		arg_list = CommandLineToArgvW(lpCmdLine, &arg_num);		if (arg_num == 2)		{			CardData data;			strcpy_s(data.username, ws2s(arg_list[0]).c_str());			strcpy_s(data.password, ws2s(arg_list[1]).c_str());			try			{				NFC_READER->Initialize();				NFC_READER->Write(data);				NFC_READER->Uninitialize();			}			catch (...)			{				MessageBox(NULL, L"
C++ HeapTupleGetOid函数代码示例
C++ HeapReAlloc函数代码示例