Dynamische geheugentoewijzing in C/C++ verwijst naar het handmatig uitvoeren van geheugentoewijzing door een programmeur. Dynamisch toegewezen geheugen wordt toegewezen Hoop, en niet-statische en lokale variabelen krijgen geheugen toegewezen Stapel (Verwijzen naar Geheugenindeling C-programma's voor details).

Wat zijn toepassingen?

• Eén gebruik van dynamisch toegewezen geheugen is het toewijzen van geheugen van variabele grootte, wat niet mogelijk is met door de compiler toegewezen geheugen, behalve voor arrays met variabele lengte .
• Het belangrijkste gebruik is de flexibiliteit die aan programmeurs wordt geboden. We zijn vrij om geheugen toe te wijzen en de toewijzing ervan ongedaan te maken wanneer we het nodig hebben en wanneer we het niet meer nodig hebben. Er zijn veel gevallen waarin deze flexibiliteit helpt. Voorbeelden van dergelijke gevallen zijn Boom , enz.

Hoe verschilt dit van geheugen dat is toegewezen aan normale variabelen?

Voor normale variabelen zoals int a, char str[10], enz. wordt geheugen automatisch toegewezen en weer vrijgegeven. Voor dynamisch toegewezen geheugen zoals int *p = new int[10] is het de verantwoordelijkheid van de programmeur om de toewijzing van geheugen ongedaan te maken wanneer het niet langer nodig is. Als de programmeur de toewijzing van geheugen niet ongedaan maakt, veroorzaakt dit een geheugenlek (de toewijzing van het geheugen wordt pas ongedaan gemaakt als het programma wordt beëindigd).

Hoe wordt geheugen toegewezen/ongedaan gemaakt in C++?
C maakt gebruik van de malloc() en calloc() functie om geheugen dynamisch toe te wijzen tijdens runtime en gebruikt een free() functie om dynamisch toegewezen geheugen vrij te maken. C++ ondersteunt deze functies en heeft ook twee operatoren nieuw En verwijderen, die de taak vervullen om het geheugen op een betere en gemakkelijkere manier toe te wijzen en vrij te maken.

nieuwe exploitant

De nieuwe operator duidt een verzoek aan voor geheugentoewijzing in de Free Store. Als er voldoende geheugen beschikbaar is, initialiseert een nieuwe operator het geheugen en retourneert het adres van het nieuw toegewezen en geïnitialiseerde geheugen naar de pointervariabele.

Syntaxis om nieuwe operator te gebruiken

topologieën

pointer-variable =   new   data-type;>

Hier is de pointervariabele de pointer van het type datatype. Het gegevenstype kan elk ingebouwd gegevenstype zijn, inclusief array, of elk door de gebruiker gedefinieerd gegevenstype, inclusief structuur en klasse.
Voorbeeld:

// Pointer initialized with NULL // Then request memory for the variable int *p = NULL;  p = new int;    OR  // Combine declaration of pointer  // and their assignment int *p = new int;>

// C++ program to demonstrate how to create dynamic variable // using new #include  #include  using namespace std; int main() {  // pointer to store the address returned by the new  int* ptr;  // allocating memory for integer  ptr = new int;  // assigning value using dereference operator  *ptr = 10;  // printing value and address  cout << 'Address: ' << ptr << endl;  cout << 'Value: ' << *ptr;  return 0; }>

Address: 0x162bc20 Value: 10>

Initialiseer geheugen: We kunnen het geheugen voor ingebouwde gegevenstypen ook initialiseren met behulp van een nieuwe operator. Voor aangepaste gegevenstypen is een constructor vereist (met het gegevenstype als invoer) voor het initialiseren van de waarde. Hier is een voorbeeld van de initialisatie van beide gegevenstypen:

pointer-variable =   new   data-type(value);>

Voorbeeld:

// C++ program to illustrate how to initialize a dynamic // variable with allocation #include  #include  using namespace std; // Custom data type with constructor to take initial value struct cust {  int p;  cust(int q)  : p(q)  {  }  cust() = default; }; int main() {  // creating inbuit data types with initial value  int* p = new int(25);  float* q = new float(75.25);  // Works fine, doesn’t require constructor  cust* var1 = new cust;  // OR  // Works fine, doesn’t require constructor  var1 = new cust();  // Notice error if you comment this line  cust* var = new cust(25);  cout << *p << ' ' << *q << ' ' << var->P;  retour 0; }>

25 75.25 25>

Wijs een geheugenblok toe: een nieuwe operator wordt ook gebruikt om een ​​blok (een array) geheugen van het type toe te wijzen data type .

pointer-variable =   new   data-type[size];>

waarbij size (een variabele) het aantal elementen in een array specificeert.

Voorbeeld:

zet in Java

int *p = new int[10]>

Wijst dynamisch geheugen toe voor 10 gehele getallen van het type int en retourneert een pointer naar het eerste element van de reeks, waaraan top (een pointer) is toegewezen. p[0] verwijst naar het eerste element, p[1] verwijst naar het tweede element, enzovoort.

Normale array-declaratie versus nieuw gebruiken
Er is een verschil tussen het declareren van een normale array en het toewijzen van een geheugenblok met behulp van new. Het belangrijkste verschil is dat de toewijzing van normale arrays door de compiler ongedaan wordt gemaakt (als de array lokaal is, wordt de toewijzing ongedaan gemaakt wanneer de functie terugkeert of is voltooid). Dynamisch toegewezen arrays blijven echter altijd daar totdat de toewijzing door de programmeur ongedaan wordt gemaakt of totdat het programma wordt beëindigd.

Wat moet ik doen als er tijdens runtime niet voldoende geheugen beschikbaar is?
Als er niet voldoende geheugen beschikbaar is in de heap om toe te wijzen, geeft het nieuwe verzoek een fout aan door een uitzondering van het type std::bad_alloc te genereren, tenzij nothrow wordt gebruikt met de nieuwe operator, in welk geval het een NULL-aanwijzer retourneert (scroll naar sectie Uitzondering afhandeling van nieuwe operator in dit artikel). Daarom kan het een goed idee zijn om te controleren op de pointervariabele die door de nieuwe wordt geproduceerd voordat u het programma ervan gebruikt.

int *p = new(nothrow) int; if (!p) {  cout << 'Memory allocation failed
'; }>

operator verwijderen

Omdat het de verantwoordelijkheid van de programmeur is om de toewijzing van dynamisch toegewezen geheugen ongedaan te maken, beschikken programmeurs over een verwijderoperator in de taal C++.

Syntaxis:

Java Compareto-methode

// Release memory pointed by pointer-variable   delete   pointer-variable;>

Hier is de pointervariabele de pointer die verwijst naar het gegevensobject dat is gemaakt door nieuw .

Voorbeelden:

delete p; delete q;>

Om de dynamisch toegewezen array vrij te maken die is aangewezen door een pointervariabele, gebruikt u de volgende vorm van verwijderen :

  // Release block of memory     // pointed by pointer-variable  delete[] pointer-variable;     Example:    // It will free the entire array    // pointed by p.   delete[] p;>

// C++ program to illustrate dynamic allocation // and deallocation of memory using new and delete #include  using namespace std; int main() {  // Pointer initialization to null  int* p = NULL;  // Request memory for the variable  // using new operator  p = new (nothrow) int;  if (!p)  cout << 'allocation of memory failed
';  else {  // Store value at allocated address  *p = 29;  cout << 'Value of p: ' << *p << endl;  }  // Request block of memory  // using new operator  float* r = new float(75.25);  cout << 'Value of r: ' << *r << endl;  // Request block of memory of size n  int n = 5;  int* q = new (nothrow) int[n];  if (!q)  cout << 'allocation of memory failed
';  else {  for (int i = 0; i < n; i++)  q[i] = i + 1;  cout << 'Value store in block of memory: ';  for (int i = 0; i < n; i++)  cout << q[i] << ' ';  }  // freed the allocated memory  delete p;  delete r;  // freed the block of allocated memory  delete[] q;  return 0; }>

Value of p: 29 Value of r: 75.25 Value store in block of memory: 1 2 3 4 5>

Tijdcomplexiteit: O(n), waarbij n de gegeven geheugengrootte is.

Gerelateerde artikelen:

• Quiz over nieuw en verwijderen
• verwijderen versus gratis