C++ dynamisch geheugen

Een goed begrip van hoe dynamisch geheugen echt werkt in C++ is essentieel om een ​​goede C++-programmeur te worden. Het geheugen in je C++-programma is verdeeld in twee delen −

• De stapel − Alle variabelen die in de functie zijn gedeclareerd, nemen geheugen van de stapel in beslag.

• De hoop − Dit is ongebruikt geheugen van het programma en kan worden gebruikt om het geheugen dynamisch toe te wijzen wanneer het programma wordt uitgevoerd.

Vaak weet u niet van tevoren hoeveel geheugen u nodig heeft om bepaalde informatie in een gedefinieerde variabele op te slaan en de grootte van het vereiste geheugen kan tijdens runtime worden bepaald.

U kunt tijdens runtime geheugen toewijzen binnen de heap voor de variabele van een bepaald type met behulp van een speciale operator in C++ die het adres van de toegewezen ruimte retourneert. Deze operator heet nieuw telefoniste.

Als u geen dynamisch toegewezen geheugen meer nodig heeft, kunt u delete . gebruiken operator, die de toewijzing van geheugen opheft dat eerder was toegewezen door de nieuwe operator.

nieuwe en verwijder operators

Er is de volgende algemene syntaxis om nieuw . te gebruiken operator om dynamisch geheugen toe te wijzen aan elk gegevenstype.

new data-type;

Hier, gegevenstype kan elk ingebouwd gegevenstype zijn, inclusief een array of door de gebruiker gedefinieerde gegevenstypen, waaronder klasse of structuur. Laten we beginnen met ingebouwde gegevenstypen. We kunnen bijvoorbeeld een aanwijzer definiëren om dubbel te typen en vervolgens vragen dat het geheugen wordt toegewezen op het moment van uitvoering. We kunnen dit doen met de nieuwe operator met de volgende uitspraken −

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

Het geheugen is mogelijk niet succesvol toegewezen als het vrije geheugen is opgebruikt. Het is dus een goede gewoonte om te controleren of de nieuwe operator de NULL-aanwijzer retourneert en de juiste actie te ondernemen zoals hieronder −

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

De malloc() functie van C, bestaat nog steeds in C++, maar het wordt aanbevolen om de functie malloc() niet te gebruiken. Het belangrijkste voordeel van new boven malloc() is dat new niet alleen geheugen toewijst, maar ook objecten construeert, wat het hoofddoel van C++ is.

Wanneer u op elk moment voelt dat een variabele die dynamisch is toegewezen niet meer nodig is, kunt u het geheugen dat deze inneemt in de gratis winkel als volgt vrijmaken met de 'delete'-operator −

delete pvalue;        // Release memory pointed to by pvalue

Laten we bovenstaande concepten plaatsen en het volgende voorbeeld vormen om te laten zien hoe 'nieuw' en 'verwijderen' werken −

#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;
}

Als we bovenstaande code compileren en uitvoeren, zou dit het volgende resultaat opleveren −

Value of pvalue : 29495

Dynamische geheugentoewijzing voor arrays

Overweeg dat u geheugen wilt toewijzen voor een reeks tekens, d.w.z. een reeks van 20 tekens. Met dezelfde syntaxis die we hierboven hebben gebruikt, kunnen we geheugen dynamisch toewijzen, zoals hieronder wordt weergegeven.

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

Om de array te verwijderen die we zojuist hebben gemaakt, ziet de instructie er als volgt uit −

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

Door de vergelijkbare generieke syntaxis van de nieuwe operator te volgen, kunt u als volgt een multidimensionale array toewijzen −

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

De syntaxis om het geheugen vrij te geven voor multidimensionale arrays blijft echter hetzelfde als hierboven −

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

Dynamische geheugentoewijzing voor objecten

Objecten verschillen niet van eenvoudige gegevenstypen. Beschouw bijvoorbeeld de volgende code waarin we een reeks objecten gaan gebruiken om het concept te verduidelijken −

#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;
}

Als u een array van vier Box-objecten zou toewijzen, zou de Simple-constructor vier keer worden aangeroepen en op dezelfde manier wordt de destructor tijdens het verwijderen van deze objecten hetzelfde aantal keren aangeroepen.

Als we bovenstaande code compileren en uitvoeren, zou dit het volgende resultaat opleveren −

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