Gestione della memoria: esempi

Articolo
03/05/2013

In questo articolo viene descritto come MFC esegue le allocazioni e le allocazioni heap il frame per ciascuno dei tre tipi comuni di allocazioni di memoria:

Una matrice di byte
Una struttura di dati
Un oggetto

Allocazione di una matrice di byte

Per allocare una matrice di byte sul frame

Definire la matrice come illustrato nel codice seguente.La matrice verrà automaticamente eliminato e la memoria viene recuperata quando la variabile di matrice esce dal relativo ambito.
```
{
   const int BUFF_SIZE = 128; 

   // Allocate on the frame
   char myCharArray[BUFF_SIZE];
   int myIntArray[BUFF_SIZE];
   // Reclaimed when exiting scope 
}
```

Per allocare una matrice di byte (o qualsiasi tipo di dati primitivo) nell'heap

Utilizzare l'operatore di new con la sintassi delle matrici illustrata in questo esempio:

const int BUFF_SIZE = 128;

// Allocate on the heap
char* myCharArray = new char[BUFF_SIZE]; 
int* myIntArray = new int[BUFF_SIZE];

Per rilasciare le matrici dall'heap

Utilizzare l'operatore delete come segue:

delete [] myCharArray;
delete [] myIntArray;

Allocazione di una struttura di dati

Per allocare una struttura di dati sul frame

Definire la variabile di struttura come segue:

struct MyStructType { int topScore; };
void MyFunc()
{
    // Frame allocation
    MyStructType myStruct;

    // Use the struct 
    myStruct.topScore = 297;

    // Reclaimed when exiting scope
}

La memoria occupata dalla struttura viene recuperata quando si esce dal relativo ambito.

Per allocare le strutture dei dati nell'heap

Utilizzare new per allocare le strutture dei dati sull'heap e su delete per rilasciarli, come illustrato negli esempi seguenti:

// Heap allocation
MyStructType* myStruct = new MyStructType;

// Use the struct through the pointer ...
myStruct->topScore = 297;

delete myStruct;

Allocazione di un oggetto

Per allocare un oggetto sul frame

Dichiarare l'oggetto come segue:

{
   CMyClass myClass;     // Automatic constructor call here

   myClass.SomeMemberFunction();     // Use the object
}

Il distruttore dell'oggetto viene richiamato quando l'abbandono il relativo ambito.

Per allocare un oggetto nell'heap

Utilizzare l'operatore di new , che restituisce un puntatore all'oggetto, allocare gli oggetti nell'heap.Utilizzare l'operatore delete per eliminarli.

Negli esempi di frame e dell'heap si presuppone che nel costruttore di CPerson non accetta argomenti.
```
// Automatic constructor call here
CMyClass* myClass = new CMyClass;  

myClass->SomeMemberFunction();  // Use the object

delete myClass;  // Destructor invoked during delete
```
Se l'argomento del costruttore di CPerson è un puntatore a char, l'istruzione per l'allocazione di frame è:
```
CMyClass myClass("Joe Smith");
```
L'istruzione per l'allocazione per l'heap è:
```
CMyClass* myClass = new CMyClass("Joe Smith");
```

Vedere anche

Concetti

Gestione della memoria: allocazione heap

Condividi tramite