Dynamická alokácia pamäte v C/C++ znamená manuálne prideľovanie pamäte programátorom. Dynamicky alokovaná pamäť je alokovaná na halda, a nestatickým a lokálnym premenným je pridelená pamäť Stoh (Odkazujú na Rozloženie pamäte C programy pre podrobnosti).

Čo sú aplikácie?

• Jedným z použití dynamicky alokovanej pamäte je alokácia pamäte s premenlivou veľkosťou, čo nie je možné s pamäťou alokovanou kompilátorom okrem polia s premenlivou dĺžkou .
• Najdôležitejším využitím je flexibilita poskytovaná programátorom. Môžeme voľne prideľovať a udeľovať pamäť, kedykoľvek ju potrebujeme a kedykoľvek ju už nepotrebujeme. Existuje veľa prípadov, keď táto flexibilita pomáha. Príklady takýchto prípadov sú Strom , atď.

Ako sa líši od pamäte pridelenej normálnym premenným?

Pre normálne premenné ako int a, char str[10] atď. sa pamäť automaticky pridelí a uvoľní. V prípade dynamicky alokovanej pamäte, ako je int *p = new int[10], je zodpovednosťou programátora uvoľniť pamäť, keď už nie je potrebná. Ak programátor neuvoľní pamäť, spôsobí to a únik pamäte (pamäť sa neuvoľní, kým sa program neskončí).

Ako je alokovaná/dealokovaná pamäť v C++?
C používa malloc() a calloc() funkciu na dynamickú alokáciu pamäte za behu a na uvoľnenie dynamicky alokovanej pamäte používa funkciu free(). C++ podporuje tieto funkcie a má tiež dvoch operátorov Nový a vymazať, ktoré plnia úlohu prideľovania a uvoľňovania pamäte lepším a jednoduchším spôsobom.

nového operátora

Nový operátor označuje požiadavku na pridelenie pamäte na Free Store. Ak je k dispozícii dostatok pamäte, nový operátor inicializuje pamäť a vráti adresu novo pridelenej a inicializovanej pamäte do premennej ukazovateľa.

Syntax na použitie nového operátora

pokrytie výpisu

pointer-variable =   new   data-type;>

Tu je premenná pointer pointer typu data-type. Dátový typ môže byť akýkoľvek vstavaný dátový typ vrátane poľa alebo ľubovoľný užívateľom definovaný dátový typ vrátane štruktúry a triedy.
Príklad:

// 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>

Inicializácia pamäte: Pamäť pre vstavané dátové typy môžeme inicializovať aj pomocou nového operátora. Pre vlastné typy údajov je potrebný konštruktor (s typom údajov ako vstupom) na inicializáciu hodnoty. Tu je príklad inicializácie oboch typov údajov:

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

Príklad:

// 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;  návrat 0; }>

25 75.25 25>

Prideľte blok pamäte: nový operátor sa tiež používa na pridelenie bloku (pola) pamäte typu Dátový typ .

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

kde veľkosť (premenná) určuje počet prvkov v poli.

Príklad:

premenovanie priečinka v linuxe

int *p = new int[10]>

Dynamicky alokuje pamäť pre 10 celých čísel nepretržite typu int a vráti ukazovateľ na prvý prvok sekvencie, ktorému je priradený vrchol (ukazovateľ). p[0] označuje prvý prvok, p[1] označuje druhý prvok atď.

Vyhlásenie normálneho poľa verzus používanie nového
Je rozdiel medzi deklarovaním normálneho poľa a pridelením bloku pamäte pomocou nového. Najdôležitejším rozdielom je, že normálne polia sú uvoľnené kompilátorom (ak je pole lokálne, potom sa uvoľní, keď sa funkcia vráti alebo dokončí). Dynamicky pridelené polia tam však vždy zostanú, kým ich neuvoľní programátor alebo kým sa program neskončí.

Čo ak počas behu nie je k dispozícii dostatok pamäte?
Ak v halde nie je k dispozícii dostatok pamäte na pridelenie, nová požiadavka signalizuje zlyhanie vyvolaním výnimky typu std::bad_alloc, pokiaľ sa nepoužije nothrow s operátorom new, v takom prípade vráti ukazovateľ NULL (prejdite do časti Výnimka manipulácia s novým operátorom v toto článok). Preto môže byť dobrý nápad skontrolovať premennú ukazovateľa, ktorú vytvoril nový pred použitím jeho programu.

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

operátor vymazania

Keďže za uvoľnenie dynamicky pridelenej pamäte je zodpovedný programátor, programátorom sa poskytuje operátor vymazania v jazyku C++.

Syntax:

cast int do string java

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

Tu je premenná ukazovateľa ukazovateľ, ktorý ukazuje na dátový objekt vytvorený pomocou Nový .

Príklady:

delete p; delete q;>

Ak chcete uvoľniť dynamicky pridelené pole, na ktoré ukazuje premenná ukazovateľa, použite nasledujúci formulár vymazať :

  // 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>

Časová zložitosť: O(n), kde n je daná veľkosť pamäte.

Súvisiace články:

• Kvíz o novom a odstránení
• odstrániť vs zadarmo