Struttura CMemoryState

Fornisce un modo pratico per rilevare perdite di memoria nel programma.

Sintassi

struct CMemoryState

Membri

Costruttori pubblici

Nome	Descrizione
CMemoryState::CMemoryState	Costruisce una struttura simile alla classe che controlla i checkpoint di memoria.

Metodi pubblici

Nome	Descrizione
CMemoryState::Checkpoint	Ottiene uno snapshot (checkpoint) dello stato di memoria corrente.
CMemoryState::D ifference	Calcola la differenza tra due oggetti di tipo CMemoryState.
CMemoryState::D umpAllObjectsSince	Esegue il dump di un riepilogo di tutti gli oggetti attualmente allocati dopo un checkpoint precedente.
CMemoryState::D umpStatistics	Stampa le statistiche di allocazione della memoria per un CMemoryState oggetto .

Osservazioni:

CMemoryState è una struttura e non dispone di una classe di base.

Una "perdita di memoria" si verifica quando la memoria per un oggetto viene allocata nell'heap, ma non deallocata quando non è più necessaria. Tali perdite di memoria possono causare alla fine errori di memoria insufficiente. Esistono diversi modi per allocare e deallocare memoria nel programma:

• Uso della malloc/ free famiglia di funzioni dalla libreria di runtime.

• Uso delle funzioni LocalAlloc/ LocalFree di gestione della memoria dell'API Windows e .GlobalAlloc/ GlobalFree

• Uso degli operatori e delete C++new.

La CMemoryState diagnostica consente di rilevare solo le perdite di memoria causate quando la memoria allocata tramite l'operatore new non viene deallocata tramite delete. Gli altri due gruppi di funzioni di gestione della memoria sono destinati a programmi non C++ e non sono consigliati combinarli con new e delete nello stesso programma. Viene fornita una macro aggiuntiva, DEBUG_NEW, per sostituire l'operatore new quando è necessario tenere traccia delle allocazioni di memoria di file e numeri di riga. DEBUG_NEW viene usato ogni volta che si usa normalmente l'operatore new .

Come per altre diagnostica, la CMemoryState diagnostica è disponibile solo nelle versioni di debug del programma. Una versione di debug deve avere la costante _DEBUG definita.

Se si sospetta che il programma abbia una perdita di memoria, è possibile usare le Checkpointfunzioni , Differencee DumpStatistics per individuare la differenza tra lo stato della memoria (oggetti allocati) in due punti diversi nell'esecuzione del programma. Queste informazioni possono essere utili per determinare se una funzione pulisce tutti gli oggetti allocati.

Se è sufficiente sapere dove si verifica lo squilibrio nell'allocazione e la deallocazione non fornisce informazioni sufficienti, è possibile usare la funzione per eseguire il DumpAllObjectsSince dump di tutti gli oggetti allocati dopo la chiamata precedente a Checkpoint. Questo dump mostra l'ordine di allocazione, il file di origine e la riga in cui è stato allocato l'oggetto (se si usa DEBUG_NEW per l'allocazione) e la derivazione dell'oggetto, del relativo indirizzo e delle relative dimensioni. DumpAllObjectsSince chiama anche la funzione di Dump ogni oggetto per fornire informazioni sullo stato corrente.

Per altre informazioni su come usare CMemoryState e altre funzionalità di diagnostica, vedere Debug di applicazioni MFC.

Nota

Le dichiarazioni di oggetti di tipo CMemoryState e chiamate alle funzioni membro devono essere racchiuse tra parentesi per #if defined(_DEBUG)/#endif direttive. In questo modo, la diagnostica della memoria deve essere inclusa solo nelle compilazioni di debug del programma.

Gerarchia di ereditarietà

CMemoryState

Requisiti

Intestazione: afx.h

CMemoryState::Checkpoint

Acquisisce un riepilogo dello snapshot della memoria e lo archivia in questo CMemoryState oggetto.

void Checkpoint();

Osservazioni:

Le CMemoryState funzioni membro Difference e DumpAllObjectsSince usano questi dati snapshot.

Esempio

Vedere l'esempio per il costruttore CMemoryState .

CMemoryState::CMemoryState

Costruisce un oggetto vuoto CMemoryState che deve essere compilato dalla funzione membro Checkpoint o Difference .

CMemoryState();

Esempio

CMemoryState msOld;
msOld.Checkpoint();
CPerson* pper1 = new CPerson();
CPerson* pper2 = new CPerson();
msOld.DumpAllObjectsSince();

CMemoryState::D ifference

Confronta due CMemoryState oggetti, quindi archivia la differenza in questo CMemoryState oggetto.

BOOL Difference(
    const CMemoryState& oldState,
    const CMemoryState& newState);

Parametri

oldState
Stato di memoria iniziale definito da un CMemoryState checkpoint.

newState
Nuovo stato di memoria definito da un CMemoryState checkpoint.

Valore restituito

Diverso da zero se i due stati di memoria sono diversi; in caso contrario, 0.

Osservazioni:

Il checkpoint deve essere stato chiamato per ognuno dei due parametri dello stato della memoria.

Esempio

Vedere l'esempio per il costruttore CMemoryState .

CMemoryState::D umpAllObjectsSince

Chiama la Dump funzione per tutti gli oggetti di un tipo derivato dalla classe CObject allocata (e sono ancora allocati) dall'ultima chiamata checkpoint per questo CMemoryState oggetto.

void DumpAllObjectsSince() const;

Osservazioni:

La chiamata DumpAllObjectsSince con un oggetto non inizializzato CMemoryState eseguirà il dump di tutti gli oggetti attualmente in memoria.

Esempio

Vedere l'esempio per il costruttore CMemoryState .

CMemoryState::D umpStatistics

Stampa un rapporto di statistiche di memoria conciso da un CMemoryState oggetto compilato dalla funzione membro Difference .

void DumpStatistics() const;

Osservazioni:

Il report, stampato nel dispositivo afxDump , mostra quanto segue:

Un report di esempio fornisce informazioni sul numero (o sulla quantità) di:

• blocchi liberi

• blocchi normali

• Blocchi CRT

• ignorare i blocchi

• blocchi client

• memoria massima utilizzata dal programma in qualsiasi momento (in byte)

• memoria totale attualmente usata dal programma (in byte)

I blocchi liberi sono il numero di blocchi la cui deallocazione è stata ritardata se afxMemDF è stata impostata su delayFreeMemDF. Per altre informazioni, vedere afxMemDF, nella sezione "Macro e globali MFC".

Esempio

Il codice seguente deve essere inserito in projnameApp.cpp. Definire le variabili globali seguenti:

static CMemoryState oldstate, newstate, diffstate;

InitInstance Nella funzione aggiungere la riga:

oldstate.Checkpoint();

Aggiungere un gestore per la ExitInstance funzione e usare il codice seguente:

newstate.Checkpoint();
if (diffstate.Difference(oldstate, newstate))
{
   TRACE(_T("Memory leaked\n"));
   diffstate.DumpStatistics();
}

È ora possibile eseguire il programma in modalità debug per visualizzare l'output della DumpStatistics funzione.

Vedi anche

Grafico della gerarchia