HeapSetInformation-Funktion (heapapi.h)

Aktiviert Features für einen angegebenen Heap.

Syntax

BOOL HeapSetInformation(
  [in, optional] HANDLE                 HeapHandle,
  [in]           HEAP_INFORMATION_CLASS HeapInformationClass,
  [in]           PVOID                  HeapInformation,
  [in]           SIZE_T                 HeapInformationLength
);

Parameter

[in, optional] HeapHandle

Ein Handle für den Heap, in dem Informationen festgelegt werden sollen. Dieses Handle wird entweder von der Funktion HeapCreate oder GetProcessHeap zurückgegeben.

[in] HeapInformationClass

Die Klasse der festzulegenden Informationen. Dieser Parameter kann einer der folgenden Werte aus dem HEAP_INFORMATION_CLASS Enumerationstyp sein.

[in] HeapInformation

Der Heapinformationspuffer. Das Format dieser Daten hängt vom Wert des HeapInformationClass-Parameters ab.

Wenn der HeapInformationClass-ParameterHeapCompatibilityInformation ist, ist der HeapInformation-Parameter ein Zeiger auf eine ULONG-Variable .

Wenn der HeapInformationClass-ParameterHeapEnableTerminationOnCorruption ist, sollte der HeapInformation-ParameterNULL und HeapInformationLength 0 sein.

[in] HeapInformationLength

Die Größe des HeapInformation-Puffers in Bytes.

Rückgabewert

Wenn die Funktion erfolgreich ist, ist der Rückgabewert ungleich Null.

Wenn die Funktion fehlerhaft ist, ist der Rückgabewert 0 (null). Um erweiterte Fehlerinformationen zu erhalten, rufen Sie GetLastError auf.

Hinweise

Um die aktuellen Einstellungen für den Heap abzurufen, verwenden Sie die HeapQueryInformation-Funktion .

Das Festlegen der Option HeapEnableTerminateOnCorruption wird dringend empfohlen, da dies die Exposition einer Anwendung gegenüber Sicherheitsexbissen verringert, die einen beschädigten Heap ausnutzen.

Beispiele

Das folgende Beispiel zeigt, wie Sie den Heap mit geringer Fragmentierung aktivieren.

#include <windows.h>
#include <tchar.h>
#include <stdio.h>

#define HEAP_LFH 2

int __cdecl _tmain()
{
    BOOL bResult;
    HANDLE hHeap;
    ULONG HeapInformation;

    //
    // Enable heap terminate-on-corruption. 
    // A correct application can continue to run even if this call fails, 
    // so it is safe to ignore the return value and call the function as follows:
    // (void)HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
    // If the application requires heap terminate-on-corruption to be enabled, 
    // check the return value and exit on failure as shown in this example.
    //
    bResult = HeapSetInformation(NULL,
                                 HeapEnableTerminationOnCorruption,
                                 NULL,
                                 0);

    if (bResult != FALSE) {
        _tprintf(TEXT("Heap terminate-on-corruption has been enabled.\n"));
    }
    else {
        _tprintf(TEXT("Failed to enable heap terminate-on-corruption with LastError %d.\n"),
                 GetLastError());
        return 1;
    }

    //
    // Create a new heap with default parameters.
    //
    hHeap = HeapCreate(0, 0, 0);
    if (hHeap == NULL) {
        _tprintf(TEXT("Failed to create a new heap with LastError %d.\n"),
                 GetLastError());
        return 1;
    }

    //
    // Enable the low-fragmentation heap (LFH). Starting with Windows Vista, 
    // the LFH is enabled by default but this call does not cause an error.
    //
    HeapInformation = HEAP_LFH;
    bResult = HeapSetInformation(hHeap,
                                 HeapCompatibilityInformation,
                                 &HeapInformation,
                                 sizeof(HeapInformation));
    if (bResult != FALSE) {
        _tprintf(TEXT("The low-fragmentation heap has been enabled.\n"));
    }
    else {
        _tprintf(TEXT("Failed to enable the low-fragmentation heap with LastError %d.\n"),
                 GetLastError());
        return 1;
    }

    return 0;
}

Anforderungen

Siehe auch

GetProcessHeap

Heapfunktionen

HeapCreate

HeapQueryInformation

Speicherverwaltungsfunktionen