Dynamická alokace paměti v C/C++ se týká ručního přidělování paměti programátorem. Dynamicky alokovaná paměť je alokována na Halda, a nestatickým a lokálním proměnným je alokována paměť Zásobník (Odkazují na Rozložení paměti C programy pro detaily).

Co jsou aplikace?

• Jedním z použití dynamicky alokované paměti je alokace paměti proměnlivé velikosti, což není možné s pamětí alokovanou kompilátorem, kromě pole s proměnnou délkou .
• Nejdůležitějším využitím je flexibilita poskytovaná programátorům. Můžeme svobodně alokovat a uvolnit paměť, kdykoli ji potřebujeme, a kdykoli ji již nepotřebujeme. Existuje mnoho případů, kdy tato flexibilita pomáhá. Příklady takových případů jsou Strom , atd.

Jak se liší od paměti přidělené normálním proměnným?

Pro normální proměnné jako int a, char str[10] atd. je paměť automaticky alokována a uvolněna. U dynamicky alokované paměti, jako je int *p = new int[10], je odpovědností programátora uvolnit paměť, když již není potřeba. Pokud programátor neuvolní paměť, způsobí a únik paměti (paměť není uvolněna, dokud se program neskončí).

Jak je paměť alokována/dealokována v C++?
C používá malloc() a calloc() funkce k dynamickému přidělování paměti za běhu a k uvolnění dynamicky alokované paměti používá funkci free(). C++ podporuje tyto funkce a má také dva operátory Nový a vymazat, které plní úkol alokace a uvolnění paměti lepším a jednodušším způsobem.

nového operátora

Nový operátor označuje požadavek na přidělení paměti na Free Store. Pokud je k dispozici dostatek paměti, nový operátor inicializuje paměť a vrátí adresu nově přidělené a inicializované paměti do proměnné ukazatele.

Syntaxe pro použití nového operátoru

cdr plná forma

pointer-variable =   new   data-type;>

Proměnná ukazatel je zde ukazatel typu datový typ. Datový typ může být jakýkoli vestavěný datový typ včetně pole nebo jakýkoli uživatelsky definovaný datový typ včetně struktury a třídy.
Pří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>

Inicializovat paměť: Můžeme také inicializovat paměť pro vestavěné datové typy pomocí nového operátoru. Pro vlastní datové typy je vyžadován konstruktor (s datovým typem jako vstupem) pro inicializaci hodnoty. Zde je příklad inicializace obou datových typů:

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

Pří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>

Přidělte blok paměti: nový operátor se také používá k alokaci bloku (pole) paměti typu datový typ .

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

kde size(proměnná) udává počet prvků v poli.

Příklad:

10 milionů

int *p = new int[10]>

Dynamicky alokuje paměť pro 10 celých čísel nepřetržitě typu int a vrací ukazatel na první prvek sekvence, kterému je přiřazen top (ukazatel). p[0] odkazuje na první prvek, p[1] odkazuje na druhý prvek a tak dále.

Normální deklarace pole vs použití nového
Je rozdíl mezi deklarováním normálního pole a alokací bloku paměti pomocí new. Nejdůležitější rozdíl je v tom, že normální pole jsou uvolněna kompilátorem (pokud je pole lokální, pak se uvolní, když se funkce vrátí nebo dokončí). Dynamicky alokovaná pole tam však vždy zůstávají, dokud je neuvolní programátor nebo dokud se program neskončí.

Co když během běhu není k dispozici dostatek paměti?
Pokud v haldě není k dispozici dostatek paměti pro alokaci, nový požadavek indikuje selhání vyvoláním výjimky typu std::bad_alloc, pokud není použit nothrow s operátorem new, v takovém případě vrátí ukazatel NULL (přejděte do sekce Výjimka manipulace s novým operátorem v tento článek). Proto může být dobrý nápad zkontrolovat proměnnou ukazatele vytvořenou novým před použitím jeho programu.

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

odstranit operátor

Vzhledem k tomu, že je odpovědností programátora uvolnit dynamicky alokovanou paměť, je programátorům poskytnut operátor delete v jazyce C++.

Syntax:

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

Zde je proměnná ukazatele ukazatel, který ukazuje na datový objekt vytvořený Nový .

Příklady:

delete p; delete q;>

Chcete-li uvolnit dynamicky alokované pole, na které ukazuje proměnná ukazatele, použijte následující formulář vymazat :

vytvořit sh skript spustitelný

  // 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á náročnost: O(n), kde n je daná velikost paměti.

Související články:

• Kvíz na nové a smazat
• smazat vs zdarma