Condividi tramite

Classe CWin32Heap

  • Articolo

Questa classe implementa IAtlMemMgr usando le funzioni di allocazione dell'heap Win32.

Importante

Questa classe e i relativi membri non possono essere usati nelle applicazioni eseguite in Windows Runtime.

Sintassi

class CWin32Heap : public IAtlMemMgr

Membri

Costruttori pubblici

Nome Descrizione
CWin32Heap::CWin32Heap Costruttore.
CWin32Heap::~CWin32Heap Distruttore.

Metodi pubblici

Nome Descrizione
CWin32Heap::Allocate Alloca un blocco di memoria dall'oggetto heap.
CWin32Heap::Attach Associa l'oggetto heap a un heap esistente.
CWin32Heap::D etach Scollega l'oggetto heap da un heap esistente.
CWin32Heap::Free Libera memoria allocata in precedenza dall'heap.
CWin32Heap::GetSize Restituisce le dimensioni di un blocco di memoria allocato dall'oggetto heap.
CWin32Heap::Reallocate Rialloca un blocco di memoria dall'oggetto heap.

Membri dati pubblici

Nome Descrizione
CWin32Heap::m_bOwnHeap Flag utilizzato per determinare la proprietà corrente dell'handle dell'heap.
CWin32Heap::m_hHeap Handle per l'oggetto heap.

Osservazioni:

CWin32Heap implementa i metodi di allocazione della memoria usando le funzioni di allocazione dell'heap Win32, tra cui HeapAlloc e HeapFree. A differenza di altre classi heap, CWin32Heap richiede che venga fornito un handle heap valido prima dell'allocazione della memoria: per impostazione predefinita, le altre classi usano l'heap del processo. L'handle può essere fornito al costruttore o al metodo CWin32Heap::Attach . Per altri dettagli, vedere il metodo CWin32Heap::CWin32Heap .

Esempio

Vedere l'esempio per IAtlMemMgr.

Gerarchia di ereditarietà

IAtlMemMgr

CWin32Heap

Requisiti

Intestazione: atlmem.h

CWin32Heap::Allocate

Alloca un blocco di memoria dall'oggetto heap.

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

Parametri

nBytes
Numero di byte necessari nel nuovo blocco di memoria.

Valore restituito

Restituisce un puntatore all'inizio del blocco di memoria appena allocata.

Osservazioni:

Chiamare CWin32Heap::Free o CWin32Heap::Reallocate per liberare la memoria allocata da questo metodo.

Implementato tramite HeapAlloc.

CWin32Heap::Attach

Associa l'oggetto heap a un heap esistente.

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

Parametri

hHeap
Handle dell'heap esistente.

bTakeOwnership
Flag che indica se l'oggetto CWin32Heap deve assumere la proprietà delle risorse dell'heap.

Osservazioni:

Se bTakeOwnership è TRUE, l'oggetto è responsabile dell'eliminazione CWin32Heap dell'handle dell'heap.

CWin32Heap::CWin32Heap

Costruttore.

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

Parametri

hHeap
Oggetto heap esistente.

dwFlags
Flag utilizzati nella creazione dell'heap.

nInitialSize
Dimensione iniziale dell'heap.

nMaxSize
Dimensione massima dell'heap.

Osservazioni:

Prima di allocare memoria, è necessario fornire all'oggetto CWin32Heap un handle heap valido. Il modo più semplice per ottenere questo risultato consiste nell'utilizzare l'heap processo:

CWin32Heap MyHeap(GetProcessHeap());

È anche possibile fornire al costruttore un handle heap esistente, nel qual caso al nuovo oggetto non passa la proprietà dell'heap. L'handle heap originale sarà comunque valido quando l'oggetto. CWin32Heap viene eliminato.

È anche possibile associare un heap esistente al nuovo oggetto usando CWin32Heap::Attach.

Se viene richiesto un heap in un contesto in cui le operazioni vengono tutte eseguite da un singolo thread, il miglior modo consiste nel creare l'oggetto come segue:

CWin32Heap MyHeap(HEAP_NO_SERIALIZE, SomeInitialSize);

Il parametro HEAP_NO_SERIALIZE specifica che l'esclusione reciproca non verrà usata quando le funzioni heap allocano e liberano memoria, con un aumento delle prestazioni.

Il terzo parametro viene impostato sul valore predefinito 0 che consente all'heap di crescere come necessario. Vedere HeapCreate per una spiegazione delle dimensioni e dei flag di memoria.

CWin32Heap::~CWin32Heap

Distruttore.

~CWin32Heap() throw();

Osservazioni:

Elimina definitivamente l'handle dell'heap se l'oggetto CWin32Heap ha la proprietà dell'heap.

CWin32Heap::D etach

Scollega l'oggetto heap da un heap esistente.

HANDLE Detach() throw();

Valore restituito

Restituisce l'handle all'heap a cui l'oggetto è stato collegato in precedenza.

CWin32Heap::Free

Libera memoria allocata in precedenza dall'heap da CWin32Heap::Allocate o CWin32Heap::Reallocate.

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

Parametri

p
Puntatore al blocco di memoria da liberare. NULL è un valore valido e non esegue alcuna operazione.

CWin32Heap::GetSize

Restituisce le dimensioni di un blocco di memoria allocato dall'oggetto heap.

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

Parametri

p
Puntatore al blocco di memoria le cui dimensioni otterranno il metodo. Si tratta di un puntatore restituito da CWin32Heap::Allocate o CWin32Heap::Reallocate.

Valore restituito

Restituisce le dimensioni, in byte, del blocco di memoria allocato.

CWin32Heap::m_bOwnHeap

Flag utilizzato per determinare la proprietà corrente dell'handle dell'heap archiviato in m_hHeap.

bool m_bOwnHeap;

CWin32Heap::m_hHeap

Handle per l'oggetto heap.

HANDLE m_hHeap;

Osservazioni:

Variabile utilizzata per archiviare un handle per l'oggetto heap.

CWin32Heap::Reallocate

Rialloca un blocco di memoria dall'oggetto heap.

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

Parametri

p
Puntatore al blocco di memoria da riallocare.

nBytes
Nuova dimensione in byte del blocco allocato. Il blocco può essere reso più grande o più piccolo.

Valore restituito

Restituisce un puntatore all'inizio del blocco di memoria appena allocata.

Osservazioni:

Se p è NULL, si presuppone che il blocco di memoria non sia ancora stato allocato e che venga chiamato CWin32Heap::Allocate , con un argomento di nBytes.

Vedi anche

Cenni preliminari sulla classe
Classe IAtlMemMgr
Classe CLocalHeap
Classe CGlobalHeap
Classe CCRTHeap
Classe CComHeap