Gestione della memoria: esempi

Articolo
10/12/2023

Questo articolo descrive come MFC esegue allocazioni di frame e allocazioni di heap per ognuno dei tre tipi tipici di allocazioni di memoria:

Matrice di byte
Struttura dei dati
Oggetto

Allocazione di una matrice di byte

Per allocare una matrice di byte nel frame

Definire la matrice come illustrato nel codice seguente. La matrice viene eliminata automaticamente e la relativa memoria 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

Usare l'operatore new con la sintassi della matrice 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 deallocare le matrici dall'heap

Usare l'operatore delete come segue:

delete[] myCharArray;
delete[] myIntArray;

Allocazione di una struttura di dati

Per allocare una struttura di dati nel 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 esce dall'ambito.

Per allocare strutture di dati nell'heap

Usare new per allocare strutture di dati nell'heap e delete deallocarle, 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 nel frame

Dichiarare l'oggetto come segue:
```
{
CMyClass myClass;     // Automatic constructor call here

myClass.SomeMemberFunction();     // Use the object
}
```
Il distruttore per l'oggetto viene richiamato automaticamente quando l'oggetto esce dal relativo ambito.

Per allocare un oggetto nell'heap

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

Gli esempi di heap e frame seguenti presuppongono che il CPerson costruttore 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 per il CPerson costruttore è un puntatore a char, l'istruzione per l'allocazione dei frame è:
```
CMyClass myClass("Joe Smith");
```
L'istruzione per l'allocazione dell'heap è:
```
CMyClass* myClass = new CMyClass("Joe Smith");
```

Vedi anche

Gestione della memoria: allocazione di heap

Condividi tramite