Gestion de la mémoire : exemples

Article
10/12/2023

Cet article décrit comment MFC effectue des allocations d’images et des allocations de tas pour chacun des trois types typiques d’allocations de mémoire :

Tableau d’octets
Structure de données
Objet

Allocation d’un tableau d’octets

Pour allouer un tableau d’octets sur le frame

Définissez le tableau comme indiqué par le code suivant. Le tableau est automatiquement supprimé et sa mémoire récupérée lorsque la variable de tableau quitte son étendue.
```
{
const int BUFF_SIZE = 128;

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

Pour allouer un tableau d’octets (ou tout type de données primitif) sur le tas

Utilisez l’opérateur avec la new syntaxe de tableau indiquée dans cet exemple :

const int BUFF_SIZE = 128;

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

Pour libérer les tableaux à partir du tas

Utilisez l’opérateur delete comme suit :

delete[] myCharArray;
delete[] myIntArray;

Allocation d’une structure de données

Pour allouer une structure de données sur le frame

Définissez la variable de structure comme suit :

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

   // Use the struct 
   myStruct.topScore = 297;

   // Reclaimed when exiting scope
}

La mémoire occupée par la structure est récupérée lorsqu’elle quitte son étendue.

Pour allouer des structures de données sur le tas

Permet new d’allouer des structures de données sur le tas et delete de les libérer, comme illustré par les exemples suivants :

// Heap allocation
MyStructType* myStruct = new MyStructType;

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

delete myStruct;

Allocation d’un objet

Pour allouer un objet sur le frame

Déclarez l’objet comme suit :
```
{
CMyClass myClass;     // Automatic constructor call here

myClass.SomeMemberFunction();     // Use the object
}
```
Le destructeur de l’objet est automatiquement appelé lorsque l’objet quitte son étendue.

Pour allouer un objet sur le tas

Utilisez l’opérateur new , qui retourne un pointeur vers l’objet, pour allouer des objets sur le tas. Utilisez l’opérateur delete pour les supprimer.

Les exemples de tas et d’images suivants supposent que le CPerson constructeur n’accepte aucun argument.
```
// Automatic constructor call here
CMyClass* myClass = new CMyClass;

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

delete myClass;  // Destructor invoked during delete
```
Si l’argument du CPerson constructeur est un pointeur vers char, l’instruction pour l’allocation d’images est :
```
CMyClass myClass("Joe Smith");
```
L’instruction pour l’allocation de tas est la suivante :
```
CMyClass* myClass = new CMyClass("Joe Smith");
```

Voir aussi

Gestion de la mémoire : allocation de tas

Partager via