Alocarea dinamică a memoriei în C/C++ se referă la efectuarea manuală a alocării memoriei de către un programator. Memoria alocată dinamic este alocată Morman, iar variabilele non-statice și locale primesc memorie alocată Grămadă (A se referi la Programe C cu aspect de memorie pentru detalii).

Ce sunt aplicațiile?

• O utilizare a memoriei alocate dinamic este de a aloca memorie de dimensiune variabilă, ceea ce nu este posibil cu memoria alocată de compilator, cu excepția tablouri cu lungime variabilă .
• Cea mai importantă utilizare este flexibilitatea oferită programatorilor. Suntem liberi să alocăm și să dezalocam memorie ori de câte ori avem nevoie de ea și oricând nu mai avem nevoie de ea. Există multe cazuri în care această flexibilitate ajută. Exemple de astfel de cazuri sunt Copac , etc.

Cum este diferit de memoria alocată variabilelor normale?

Pentru variabile normale precum int a, char str[10], etc, memoria este alocată și dealocată automat. Pentru memoria alocată dinamic, cum ar fi int *p = new int[10], este responsabilitatea programatorului să dealocați memoria atunci când nu mai este necesară. Dacă programatorul nu dealoca memoria, provoacă a pierdere de memorie (memoria nu este dealocată până când programul se încheie).

Cum este alocată/dealocată memoria în C++?
C folosește malloc() și calloc() funcția pentru a aloca memorie dinamic în timpul rulării și folosește o funcție free() pentru a elibera memoria alocată dinamic. C++ acceptă aceste funcții și are, de asemenea, doi operatori nou și șterge, care îndeplinesc sarcina de a aloca și elibera memoria într-un mod mai bun și mai ușor.

nou operator

Noul operator denotă o solicitare de alocare de memorie pe Magazinul gratuit. Dacă este disponibilă suficientă memorie, un nou operator inițializează memoria și returnează adresa memoriei nou alocate și inițializate variabilei pointer.

Sintaxă pentru utilizarea operatorului nou

Linux gazdă

pointer-variable =   new   data-type;>

Aici, variabila pointer este pointerul de tip data-type. Tipul de date poate fi orice tip de date încorporat, inclusiv matrice sau orice tip de date definit de utilizator, inclusiv structura și clasa.
Exemplu:

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

Inițializați memoria: De asemenea, putem inițializa memoria pentru tipurile de date încorporate folosind un nou operator. Pentru tipurile de date personalizate, este necesar un constructor (cu tipul de date ca intrare) pentru inițializarea valorii. Iată un exemplu de inițializare a ambelor tipuri de date:

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

Exemplu:

// 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;  întoarce 0; }>>>  
  Ieșire  
25 75.25 25>
  
    Alocați un bloc de memorie:    un nou operator este de asemenea folosit pentru a aloca un bloc (o matrice) de memorie de tip    tip de date    .
 unde dimensiunea (o variabilă) specifică numărul de elemente dintr-o matrice.
 
    Exemplu:    
linkedlist java
 
int *p = new int[10]>
Alocă în mod dinamic memorie pentru 10 numere întregi în mod continuu de tip int și returnează un pointer la primul element al secvenței, căruia i se atribuie top(un pointer). p[0] se referă la primul element, p[1] se referă la al doilea element și așa mai departe.
 
 
 
 
 
    Declarație de matrice normală vs       
Există o diferență între declararea unui tablou normal și alocarea unui bloc de memorie folosind new. Cea mai importantă diferență este că tablourile normale sunt dealocate de către compilator (dacă tabloul este local, atunci dealocate când funcția revine sau se completează). Cu toate acestea, matricele alocate dinamic rămân întotdeauna acolo până când fie sunt dealocate de către programator, fie programul se încheie.
 
    Ce se întâmplă dacă nu este disponibilă suficientă memorie în timpul rulării?       
Dacă nu este suficientă memorie disponibilă în heap pentru a o aloca, noua solicitare indică eșec prin aruncarea unei excepții de tip std::bad_alloc, cu excepția cazului în care nothrow este utilizat cu noul operator, caz în care returnează un pointer NULL (defilați la secțiunea Excepție manipularea noului operator în  acest  articol). Prin urmare, ar putea fi o idee bună să verificați variabila pointer produsă de nou înainte de a utiliza programul său.
 
int *p = new(nothrow) int; if (!p) {  cout << 'Memory allocation failed
'; }>
    operator de ștergere    
Deoarece este responsabilitatea programatorului să dealocați memoria alocată dinamic, programatorilor li se oferă operator de ștergere în limbajul C++.
 
    Sintaxă:     
 
// Release memory pointed by pointer-variable   delete   pointer-variable;>
Aici, variabila pointer este pointerul care indică obiectul de date creat de      nou      .
 
    Exemple:    
 
delete p; delete q;>
Pentru a elibera matricea alocată dinamic indicată de variabila pointer, utilizați următoarea formă de    șterge    :
entitate relaţională
 
  // Release block of memory     // pointed by pointer-variable  delete[] pointer-variable;     Example:    // It will free the entire array    // pointed by p.   delete[] p;>
CPP 
// 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; }>
   
  Ieșire  
Value of p: 29 Value of r: 75.25 Value store in block of memory: 1 2 3 4 5>
 
    Complexitatea timpului:    O(n), unde n este dimensiunea memoriei dată.
 
    Articole similare:    
 
 Test pentru noi și șterge 
 șterge vs gratuit