HeapSetInformation, fonction (heapapi.h)

Active les fonctionnalités d’un tas spécifié.

Syntaxe

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

Paramètres

[in, optional] HeapHandle

Handle vers le tas où les informations doivent être définies. Ce handle est retourné par la fonction HeapCreate ou GetProcessHeap .

[in] HeapInformationClass

Classe d’informations à définir. Ce paramètre peut être l’une des valeurs suivantes du type d’énumération HEAP_INFORMATION_CLASS .

[in] HeapInformation

Mémoire tampon d’informations de tas. Le format de ces données dépend de la valeur du paramètre HeapInformationClass .

Si le paramètre HeapInformationClass est HeapCompatibilityInformation, le paramètre HeapInformation est un pointeur vers une variable ULONG .

Si le paramètre HeapInformationClass est HeapEnableTerminationOnCorruption, le paramètre HeapInformation doit être NULL et HeapInformationLength doit avoir la valeur 0

[in] HeapInformationLength

Taille de la mémoire tampon HeapInformation , en octets.

Valeur retournée

Si la fonction réussit, la valeur de retour est différente de zéro.

Si la fonction échoue, la valeur de retour est zéro (0). Pour obtenir des informations détaillées sur l’erreur, appelez GetLastError.

Remarques

Pour récupérer les paramètres actuels du tas, utilisez la fonction HeapQueryInformation .

La définition de l’option HeapEnableTerminateOnCorruption est fortement recommandée, car elle réduit l’exposition d’une application aux attaques de sécurité qui tirent parti d’un tas endommagé.

Exemples

L’exemple suivant montre comment activer le tas à faible fragmentation.

#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;
}

Configuration requise

Voir aussi

GetProcessHeap

Fonctions de tas

TasCréer

HeapQueryInformation

Fonctions de gestion de la mémoire