Gestione della memoria: esempi

Articolo
06/10/2015

In questo articolo viene descritto come MFC esegue le allocazioni e allocazioni heap di frame per ciascuno dei tre tipi comuni delle 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 in qualsiasi tipo di dati primitivo) nell'heap

Utilizzare l'operatore di nuova 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 di eliminazione come segue:
```
delete [] myCharArray;
delete [] myIntArray;
```

Allocazione di una struttura di dati

Per allocare una struttura di dati sul frame

Definire una 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 esce dal relativo ambito.

Per allocare le strutture di dati nell'heap

Utilizzare nuova per allocare le strutture dei dati sull'heap e su eliminazione 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 verrà richiamato quando l'oggetto esce dal relativo ambito.

Per allocare un oggetto di l

Utilizzare l'operatore di nuova, che restituisce un puntatore all'oggetto, allocare gli oggetti nell'heap. Utilizzare l'operatore di eliminazione 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 dell'allocazione heap è:
```
CMyClass* myClass = new CMyClass("Joe Smith");
```

Vedere anche

Concetti

Gestione della memoria: allocazione di heap

Condividi tramite