Dynamisk minneallokering i C/C++ refererer til å utføre minneallokering manuelt av en programmerer. Dynamisk tildelt minne er allokert på haug, og ikke-statiske og lokale variabler får minne allokert på Stable (Referere til Minneoppsett C-programmer for detaljer).

Hva er applikasjoner?

• En bruk av dynamisk tildelt minne er å tildele minne av variabel størrelse, noe som ikke er mulig med kompilatortildelt minne bortsett fra arrays med variabel lengde .
• Den viktigste bruken er fleksibiliteten som gis til programmerere. Vi står fritt til å tildele og deallokere minne når vi trenger det og når vi ikke trenger det lenger. Det er mange tilfeller der denne fleksibiliteten hjelper. Eksempler på slike tilfeller er Tre , etc.

Hvordan er det forskjellig fra minne som er allokert til normale variabler?

For normale variabler som int a, char str[10], osv., blir minne automatisk allokert og deallokert. For dynamisk allokert minne som int *p = new int[10], er det programmererens ansvar å deallokere minne når det ikke lenger er nødvendig. Hvis programmereren ikke tildeler minne, forårsaker det en hukommelsestap (minnet blir ikke deallokert før programmet avsluttes).

Hvordan tildeles/deallokeres minne i C++?
C bruker malloc() og calloc() funksjon for å tildele minne dynamisk under kjøring og bruker en free() funksjon for å frigjøre dynamisk allokert minne. C++ støtter disse funksjonene og har også to operatører ny og slette, som utfører oppgaven med å tildele og frigjøre minnet på en bedre og enklere måte.

ny operatør

Den nye operatøren angir en forespørsel om minnetildeling på Free Store. Hvis tilstrekkelig minne er tilgjengelig, initialiserer en ny operatør minnet og returnerer adressen til det nylig tildelte og initialiserte minnet til pekervariabelen.

Syntaks for å bruke ny operator

for loops java

pointer-variable =   new   data-type;>

Her er pekervariabelen pekeren av typen datatype. Datatype kan være hvilken som helst innebygd datatype inkludert array eller en hvilken som helst brukerdefinert datatype inkludert 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 minne: Vi kan også initialisere minnet for innebygde datatyper ved hjelp av en ny operatør. For egendefinerte datatyper kreves en konstruktør (med datatypen som input) for å initialisere verdien. Her er et eksempel på initialisering av 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;  returner 0; }>

25 75.25 25>

Tildel en minneblokk: en ny operatør brukes også til å tildele en blokk (en matrise) med minne av typen data-type .

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

hvor størrelse(en variabel) angir antall elementer i en matrise.

Eksempel:

string concat java

int *p = new int[10]>

Tildeler dynamisk minne for 10 heltall kontinuerlig av typen int og returnerer en peker til det første elementet i sekvensen, som er tildelt topp (en peker). p[0] refererer til det første elementet, p[1] refererer til det andre elementet, og så videre.

Normal Array Declaration kontra bruk av ny
Det er en forskjell mellom å deklarere en normal matrise og tildele en blokk med minne ved å bruke ny. Den viktigste forskjellen er at normale arrays deallokeres av kompilatoren (Hvis arrayen er lokal, så deallokeres når funksjonen returnerer eller fullfører). Imidlertid forblir dynamisk tildelte arrays alltid der til enten de blir deallokert av programmereren eller programmet avsluttes.

Hva om nok minne ikke er tilgjengelig under kjøring?
Hvis nok minne ikke er tilgjengelig i heapen til å tildele, indikerer den nye forespørselen feil ved å kaste et unntak av typen std::bad_alloc, med mindre nothrow brukes med den nye operatøren, i så fall returnerer den en NULL-peker (rull til seksjonen Unntak håndtering av ny operatør i dette artikkel). Derfor kan det være en god idé å se etter pekervariabelen som er produsert av den nye før du bruker programmet.

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

slett operatør

Siden det er programmererens ansvar å deallokere dynamisk tildelt minne, får programmerere sletteoperatør på C++-språk.

Syntaks:

relasjonsalgebra i rdbms

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

Her er pekervariabelen pekeren som peker til dataobjektet opprettet av ny .

Eksempler:

delete p; delete q;>

For å frigjøre den dynamisk tildelte matrisen pekt av pekervariabel, bruk 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 gitte minnestørrelsen.

Relaterte artikler:

• Quiz på nytt og slett
• slett vs gratis