Gestion de la mémoire : exemples

Article
03/04/2013

Cet article explique comment MFC exécute des allocations et des allocations de tas de frame pour les trois genres classiques des allocations de mémoire :

Un tableau d'octets
Une 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ée et sa mémoire libérée lorsque la variable tableau s'arrête sa portée.
```
{
   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 primitive) sur le tas

Utilisez l'opérateur de new avec la syntaxe de tableau illustré 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 du tas

Utilisez l'opérateur de suppression 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 libérée lorsqu'elle est fermée sa portée.

Pour allouer des structures de données sur le tas

Utilisez new pour allouer des structures de données sur le tas et suppression pour les libérer, comme le montrent 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 appelé automatiquement lorsque l'objet quitte sa portée.

Pour allouer un objet sur le tas

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

Les exemples suivants de tas et de frame supposent que le constructeur d' CPerson ne prend pas d'arguments.
```
// Automatic constructor call here
CMyClass* myClass = new CMyClass;  

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

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

Voir aussi

Concepts

Gestion de la mémoire : Allocation de tas

Partager via