Dynamisk hukommelsesallokering i C/C++ refererer til at udføre hukommelsesallokering manuelt af en programmør. Dynamisk allokeret hukommelse er allokeret på bunke, og ikke-statiske og lokale variabler får hukommelse allokeret på Stak (Henvise til Hukommelseslayout C-programmer for detaljer).

Hvad er applikationer?

• En anvendelse af dynamisk allokeret hukommelse er at allokere hukommelse af variabel størrelse, hvilket ikke er muligt med compiler allokeret hukommelse bortset fra arrays med variabel længde .
• Den vigtigste anvendelse er fleksibiliteten til programmører. Vi er frie til at tildele og deallokere hukommelse, når vi har brug for det, og når vi ikke har brug for det længere. Der er mange tilfælde, hvor denne fleksibilitet hjælper. Eksempler på sådanne tilfælde er Træ , etc.

Hvordan er det forskelligt fra hukommelse, der er allokeret til normale variabler?

For normale variabler som int a, char str[10], osv., tildeles og deallokeres hukommelsen automatisk. For dynamisk allokeret hukommelse som int *p = new int[10], er det programmørens ansvar at deallokere hukommelse, når den ikke længere er nødvendig. Hvis programmøren ikke tildeler hukommelse, forårsager det en hukommelsestab (hukommelsen deallokeres ikke, før programmet afsluttes).

Hvordan er hukommelse allokeret/deallokeret i C++?
C bruger malloc() og calloc() funktion til at allokere hukommelse dynamisk under kørsel og bruger en free() funktion til at frigøre dynamisk allokeret hukommelse. C++ understøtter disse funktioner og har også to operatører ny og slette, der udfører opgaven med at tildele og frigøre hukommelsen på en bedre og lettere måde.

ny operatør

Den nye operatør angiver en anmodning om hukommelsesallokering på Free Store. Hvis tilstrækkelig hukommelse er tilgængelig, initialiserer en ny operatør hukommelsen og returnerer adressen på den nyligt allokerede og initialiserede hukommelse til pointervariablen.

Syntaks for at bruge ny operator

til loops java

pointer-variable =   new   data-type;>

Her er pointervariablen pointer af typen data-type. Datatype kan være en hvilken som helst indbygget datatype inklusive array eller enhver brugerdefineret datatype inklusive struktur og klasse.
Eksempel:

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

Initialiser hukommelsen: Vi kan også initialisere hukommelsen til indbyggede datatyper ved hjælp af en ny operatør. For brugerdefinerede datatyper kræves en konstruktør (med datatypen som input) for at initialisere værdien. Her er et eksempel på initialisering af begge datatyper:

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

Eksempel:

// 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;  retur 0; }>

25 75.25 25>

Tildel en hukommelsesblok: en ny operatør bruges også til at allokere en blok (en matrix) af hukommelse af typen datatype .

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

hvor størrelse(en variabel) angiver antallet af elementer i et array.

Eksempel:

bfs og dfs

int *p = new int[10]>

Tildeler dynamisk hukommelse til 10 heltal kontinuerligt af typen int og returnerer en pointer til det første element i sekvensen, som er tildelt top(en pointer). p[0] henviser til det første element, p[1] henviser til det andet element, og så videre.

Normal Array Declaration vs Brug af ny
Der er forskel på at erklære et normalt array og tildele en blok hukommelse ved hjælp af ny. Den vigtigste forskel er, at normale arrays deallokeres af compileren (hvis arrayet er lokalt, så deallokeres når funktionen returnerer eller afsluttes). Dynamisk allokerede arrays forbliver dog altid der, indtil de enten deallokeres af programmøren, eller programmet afsluttes.

Hvad hvis der ikke er nok hukommelse til rådighed under kørsel?
Hvis der ikke er nok hukommelse til rådighed i heapen til at allokere, indikerer den nye anmodning fejl ved at kaste en undtagelse af typen std::bad_alloc, medmindre nothrow bruges med den nye operator, i hvilket tilfælde den returnerer en NULL pointer (rul til afsnittet Undtagelser håndtering af ny operatør i det her artikel). Derfor kan det være en god idé at tjekke for den pointer-variabel, der er produceret af den nye, før du bruger dens program.

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

slet operatør

Da det er programmørens ansvar at deallokere dynamisk allokeret hukommelse, får programmører en sletoperator på C++ sprog.

Syntaks:

relationel algebra i rdbms

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

Her er pointervariablen den pointer, der peger på dataobjektet, der er oprettet af ny .

Eksempler:

delete p; delete q;>

For at frigøre det dynamisk allokerede array, der peges af pointervariabel, skal du bruge følgende form for slette :

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

Tidskompleksitet: O(n), hvor n er den givne hukommelsesstørrelse.

Relaterede artikler:

• Quiz om nyt og slet
• slet vs gratis