Dinaminis atminties paskirstymas C/C++ reiškia atminties paskirstymą rankiniu būdu programuotojo. Dinamiškai paskirstyta atmintis yra skirta krūva, o nestatiniams ir vietiniams kintamiesiems skiriama atmintis Stack (Atsižvelgti į Atminties išdėstymo C programos Norėdami gauti daugiau informacijos).

Kas yra programos?

• Vienas iš dinamiškai paskirstytos atminties panaudojimo būdų yra skirti kintamo dydžio atmintį, o tai neįmanoma naudojant kompiliatoriaus paskirstytą atmintį, išskyrus kintamo ilgio masyvai .
• Svarbiausias panaudojimas yra programuotojams suteikiamas lankstumas. Esame laisvi paskirstyti ir perskirstyti atmintį, kai mums jos reikia ir kada jos nebereikia. Yra daug atvejų, kai šis lankstumas padeda. Tokių atvejų pavyzdžiai yra Medis ir kt.

Kuo ji skiriasi nuo įprastiems kintamiesiems skirtos atminties?

Įprastiems kintamiesiems, pvz., int a, char str[10] ir t. t., atmintis paskirstoma ir atlaisvinama automatiškai. Jei tai dinamiškai paskirstyta atmintis, pvz., int *p = naujas int[10], programuotojas yra atsakingas už atmintį, kai jos nebereikia. Jei programuotojas neišskiria atminties, tai sukelia a atminties nutekėjimas (atmintis neatskiriama tol, kol programa nesibaigia).

Kaip atmintis paskirstoma / išskiriama C++?
C naudoja malloc() ir calloc() funkcija dinamiškai paskirstyti atmintį vykdymo metu ir naudoja funkciją free() dinamiškai paskirstytai atminčiai atlaisvinti. C++ palaiko šias funkcijas ir taip pat turi du operatorius naujas ir Ištrinti, kurios atlieka atminties paskirstymo ir atlaisvinimo užduotį geriau ir lengviau.

naujas operatorius

Naujasis operatorius reiškia atminties paskirstymo užklausą nemokamoje parduotuvėje. Jei yra pakankamai atminties, naujas operatorius inicijuoja atmintį ir grąžina naujai paskirtos ir inicijuotos atminties adresą žymeklio kintamajam.

Sintaksė norint naudoti naują operatorių

java mvc

pointer-variable =   new   data-type;>

Čia žymeklio kintamasis yra duomenų tipo rodyklė. Duomenų tipas gali būti bet koks integruotas duomenų tipas, įskaitant masyvą, arba bet koks vartotojo apibrėžtas duomenų tipas, įskaitant struktūrą ir klasę.
Pavyzdys:

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

Inicijuoti atmintį: Taip pat galime inicijuoti įtaisytųjų duomenų tipų atmintį naudodami naują operatorių. Pasirinktiniams duomenų tipams reikalingas konstruktorius (su duomenų tipu kaip įvestis), kad inicijuotų reikšmę. Štai abiejų tipų duomenų inicijavimo pavyzdys:

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

Pavyzdys:

// 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;  grąžinti 0; }>

25 75.25 25>

Paskirstykite atminties bloką: naujas operatorius taip pat naudojamas tam tikro tipo atminties blokui (masyvai) priskirti duomenų tipas .

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

kur dydis (kintamasis) nurodo elementų skaičių masyve.

Pavyzdys:

kas yra myspace

int *p = new int[10]>

Dinamiškai paskirsto atmintį 10 sveikųjų skaičių, kurių tipas yra int, ir grąžina žymeklį į pirmąjį sekos elementą, kuris priskirtas viršuje (žymiklis). p[0] nurodo pirmąjį elementą, p[1] – antrąjį elementą ir pan.

Įprasta masyvo deklaracija prieš naudojant naują
Yra skirtumas tarp įprasto masyvo deklaravimo ir atminties bloko paskirstymo naudojant naują. Svarbiausias skirtumas yra tas, kad įprastus masyvus atlaisvina kompiliatorius (jei masyvas yra vietinis, tada atšaukiamas, kai funkcija grįžta arba baigiama). Tačiau dinamiškai paskirstyti masyvai visada lieka ten, kol juos neatskiria programuotojas arba programa baigiama.

Ką daryti, jei vykdymo metu nėra pakankamai atminties?
Jei krūvoje nėra pakankamai atminties paskirstyti, nauja užklausa rodo gedimą, išmesdama std::bad_alloc tipo išimtį, nebent su naujuoju operatoriumi naudojamas nothrow, tokiu atveju jis grąžina NULL rodyklę (slinkite į skyrių Išimtis naujo operatoriaus tvarkymas tai straipsnis). Todėl gali būti naudinga patikrinti naujojo sukurtą rodyklės kintamąjį prieš naudojant programą.

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

ištrinti operatorių

Kadangi už dinamiškai paskirstytos atminties paskirstymą yra atsakingas programuotojas, programuotojams suteikiamas trynimo operatorius C++ kalba.

Sintaksė:

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

Čia žymeklio kintamasis yra žymeklis, nukreipiantis į sukurtą duomenų objektą naujas .

Pavyzdžiai:

labas pasaulis java

delete p; delete q;>

Norėdami atlaisvinti dinamiškai priskirtą masyvą, nukreiptą žymeklio kintamuoju, naudokite šią formą Ištrinti :

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

Laiko sudėtingumas: O(n), kur n yra nurodytas atminties dydis.

Susiję straipsniai:

• Viktorina apie naujus ir ištrinkite
• ištrinti vs nemokamai