CWin32Heap, classe

Cette classe implémente IAtlMemMgr à l’aide des fonctions d’allocation de tas Win32.

Syntaxe

class CWin32Heap : public IAtlMemMgr

Membres

Constructeurs publics

Méthodes publiques

Membres de données publics

Notes

CWin32Heap implémente des méthodes d’allocation de mémoire à l’aide des fonctions d’allocation de tas Win32, notamment HeapAlloc et HeapFree. Contrairement à d’autres classes de tas, CWin32Heap un handle de tas valide doit être fourni avant l’allocation de la mémoire : les autres classes par défaut utilisent le tas de processus. Le handle peut être fourni au constructeur ou à la méthode CWin32Heap ::Attach . Pour plus d’informations, consultez la méthode CWin32Heap ::CWin32Heap .

Exemple

Consultez l’exemple pour IAtlMemMgr.

Hiérarchie d'héritage

IAtlMemMgr

CWin32Heap

Spécifications

En-tête : atlmem.h

CWin32Heap ::Allocate

Alloue un bloc de mémoire à partir de l'objet de tas.

virtual __declspec(allocator) void* Allocate(size_t nBytes) throw();

Paramètres

octets
Nombre demandé d'octets dans le nouveau bloc de mémoire.

Valeur de retour

Retourne un pointeur vers le bloc de mémoire nouvellement alloué.

Notes

Appelez CWin32Heap ::Free ou CWin32Heap ::Reallocate pour libérer la mémoire allouée par cette méthode.

Implémenté à l’aide de HeapAlloc.

CWin32Heap ::Attach

Attache l’objet tas à un tas existant.

void Attach(HANDLE hHeap, bool bTakeOwnership) throw();

Paramètres

hHeap
Handle de tas existant.

bTakeOwnership
Indicateur indiquant si l’objet CWin32Heap doit prendre possession des ressources du tas.

Notes

Si bTakeOwnership a la valeur TRUE, l’objet CWin32Heap est responsable de la suppression du handle de tas.

CWin32Heap ::CWin32Heap

Constructeur .

CWin32Heap() throw();
CWin32Heap( HANDLE  hHeap) throw();
CWin32Heap(
    DWORD  dwFlags,
    size_t nInitialSize,
    size_t nMaxSize = 0);

Paramètres

hHeap
Objet de tas existant.

dwFlags
Indicateurs utilisés pour créer le tas.

nInitialSize
Taille initiale du tas.

nMaxSize
Taille maximale du tas.

Notes

Avant d'allouer de la mémoire, il est nécessaire de fournir à l'objet CWin32Heap un handle de tas valide. La façon la plus simple d'y parvenir consiste à utiliser le tas du processus :

CWin32Heap MyHeap(GetProcessHeap());   

Il est également possible de fournir un handle de tas existant au constructeur, auquel cas le nouvel objet ne prend pas possession du tas. Le handle de tas d'origine est toujours valide lorsque l'objet CWin32Heap est supprimé.

Un tas existant peut également être attaché au nouvel objet, à l’aide de CWin32Heap ::Attach.

Si un tas est requis lorsque des opérations sont toutes exécutées à partir d'un seul thread, il est préférable de créer l'objet comme suit :

CWin32Heap MyHeap(HEAP_NO_SERIALIZE, SomeInitialSize);   

Le paramètre HEAP_NO_SERIALIZE spécifie que l’exclusion mutuelle ne sera pas utilisée lorsque les fonctions de tas allouent et libèrent de la mémoire, avec une augmentation en fonction des performances.

Le troisième paramètre est 0 par défaut, ce qui permet au tas de s'accroître en fonction des besoins. Consultez HeapCreate pour obtenir une explication des tailles et indicateurs de mémoire.

CWin32Heap ::~CWin32Heap

Destructeur.

~CWin32Heap() throw();

Notes

Détruit le handle de tas si l’objet CWin32Heap possède la propriété du tas.

CWin32Heap ::D etach

Détache l’objet tas d’un tas existant.

HANDLE Detach() throw();

Valeur de retour

Retourne le handle au tas auquel l’objet a été précédemment attaché.

CWin32Heap ::Free

Libère la mémoire précédemment allouée à partir du tas par CWin32Heap ::Allocate ou CWin32Heap ::Reallocate.

virtual void Free(void* p) throw();

Paramètres

p
Pointeur vers le bloc de mémoire à libérer. NULL est une valeur valide et ne fait rien.

CWin32Heap ::GetSize

Retourne la taille d’un bloc de mémoire alloué à partir de l’objet tas.

virtual size_t GetSize(void* p) throw();

Paramètres

p
Pointeur vers le bloc de mémoire dont la taille est obtenue par la méthode. Il s’agit d’un pointeur retourné par CWin32Heap ::Allocate ou CWin32Heap ::Reallocate.

Valeur de retour

Retourne la taille, en octets, du bloc de mémoire alloué.

CWin32Heap ::m_bOwnHeap

Indicateur utilisé pour déterminer la propriété actuelle du handle de tas stocké dans m_hHeap.

bool m_bOwnHeap;

CWin32Heap ::m_hHeap

Handle vers l’objet tas.

HANDLE m_hHeap;

Notes

Variable utilisée pour stocker un handle dans l’objet tas.

CWin32Heap ::Reallocate

Réalloue un bloc de mémoire à partir de l'objet de tas.

virtual __declspec(allocator) void* Reallocate(void* p, size_t nBytes) throw();

Paramètres

p
Pointeur vers le bloc de mémoire à réallouer.

octets
Nouvelle taille en octets du bloc alloué. Le bloc peut être agrandi ou réduit.

Valeur de retour

Retourne un pointeur vers le bloc de mémoire nouvellement alloué.

Notes

Si p est NULL, il est supposé que le bloc de mémoire n’a pas encore été alloué et que CWin32Heap ::Allocate est appelé, avec un argument de nBytes.

Voir aussi

Vue d’ensemble de la classe
IAtlMemMgr, classe
CLocalHeap, classe
CGlobalHeap, classe
CCRTHeap, classe
CComHeap, classe