Mémoire dynamique C++

Une bonne compréhension du fonctionnement réel de la mémoire dynamique en C++ est essentielle pour devenir un bon programmeur C++. La mémoire de votre programme C++ est divisée en deux parties −

• La pile − Toutes les variables déclarées à l'intérieur de la fonction occuperont de la mémoire dans la pile.

• Le tas − Il s'agit de la mémoire inutilisée du programme et peut être utilisée pour allouer dynamiquement la mémoire lors de l'exécution du programme.

Souvent, vous ne savez pas à l'avance la quantité de mémoire dont vous aurez besoin pour stocker des informations particulières dans une variable définie et la taille de la mémoire requise peut être déterminée au moment de l'exécution.

Vous pouvez allouer de la mémoire au moment de l'exécution dans le tas pour la variable d'un type donné à l'aide d'un opérateur spécial en C++ qui renvoie l'adresse de l'espace alloué. Cet opérateur s'appelle nouveau opérateur.

Si vous n'avez plus besoin de mémoire allouée dynamiquement, vous pouvez utiliser supprimer , qui désalloue la mémoire précédemment allouée par le nouvel opérateur.

créer et supprimer des opérateurs

Il y a la syntaxe générique suivante pour utiliser new opérateur pour allouer dynamiquement de la mémoire pour tout type de données.

new data-type;

Ici, type de données peut être n'importe quel type de données intégré, y compris un tableau ou n'importe quel type de données défini par l'utilisateur, y compris une classe ou une structure. Commençons par les types de données intégrés. Par exemple, nous pouvons définir un pointeur pour taper double puis demander que la mémoire soit allouée au moment de l'exécution. Nous pouvons le faire en utilisant le nouveau opérateur avec les déclarations suivantes −

double* pvalue  = NULL; // Pointer initialized with null
pvalue  = new double;   // Request memory for the variable

La mémoire n'a peut-être pas été allouée correctement si la mémoire libre a été épuisée. Il est donc recommandé de vérifier si le nouvel opérateur renvoie le pointeur NULL et de prendre les mesures appropriées comme ci-dessous −

double* pvalue  = NULL;
if( !(pvalue  = new double )) {
   cout << "Error: out of memory." <<endl;
   exit(1);
}

Le malloc() fonction de C, existe toujours en C++, mais il est recommandé d'éviter d'utiliser la fonction malloc(). Le principal avantage de new par rapport à malloc() est que new ne se contente pas d'allouer de la mémoire, il construit des objets, ce qui est l'objectif principal de C++.

À tout moment, lorsque vous sentez qu'une variable qui a été allouée dynamiquement n'est plus nécessaire, vous pouvez libérer la mémoire qu'elle occupe dans le magasin libre avec l'opérateur 'delete' comme suit −

delete pvalue;        // Release memory pointed to by pvalue

Mettons les concepts ci-dessus et formons l'exemple suivant pour montrer comment "nouveau" et "supprimer" fonctionnent −

Démo en direct

#include <iostream>
using namespace std;

int main () {
   double* pvalue  = NULL; // Pointer initialized with null
   pvalue  = new double;   // Request memory for the variable
 
   *pvalue = 29494.99;     // Store value at allocated address
   cout << "Value of pvalue : " << *pvalue << endl;

   delete pvalue;         // free up the memory.

   return 0;
}

Si nous compilons et exécutons le code ci-dessus, cela produirait le résultat suivant −

Value of pvalue : 29495

Allocation de mémoire dynamique pour les baies

Considérez que vous souhaitez allouer de la mémoire pour un tableau de caractères, c'est-à-dire une chaîne de 20 caractères. En utilisant la même syntaxe que celle que nous avons utilisée ci-dessus, nous pouvons allouer de la mémoire de manière dynamique, comme indiqué ci-dessous.

char* pvalue  = NULL;         // Pointer initialized with null
pvalue  = new char[20];       // Request memory for the variable

Pour supprimer le tableau que nous venons de créer, l'instruction ressemblerait à ceci −

delete [] pvalue;             // Delete array pointed to by pvalue

En suivant la syntaxe générique similaire de l'opérateur new, vous pouvez allouer pour un tableau multidimensionnel comme suit −

double** pvalue  = NULL;      // Pointer initialized with null 
pvalue  = new double [3][4];  // Allocate memory for a 3x4 array 

Cependant, la syntaxe pour libérer la mémoire pour les tableaux multidimensionnels restera la même que ci-dessus −

delete [] pvalue;            // Delete array pointed to by pvalue

Allocation de mémoire dynamique pour les objets

Les objets ne sont pas différents des types de données simples. Par exemple, considérons le code suivant où nous allons utiliser un tableau d'objets pour clarifier le concept −

Démo en direct

#include <iostream>
using namespace std;

class Box {
   public:
      Box() { 
         cout << "Constructor called!" <<endl; 
      }
      ~Box() { 
         cout << "Destructor called!" <<endl; 
      }
};
int main() {
   Box* myBoxArray = new Box[4];
   delete [] myBoxArray; // Delete array

   return 0;
}

Si vous deviez allouer un tableau de quatre objets Box, le constructeur Simple serait appelé quatre fois et de même lors de la suppression de ces objets, le destructeur sera également appelé le même nombre de fois.

Si nous compilons et exécutons le code ci-dessus, cela produirait le résultat suivant −

Constructor called!
Constructor called!
Constructor called!
Constructor called!
Destructor called!
Destructor called!
Destructor called!
Destructor called!