Dinamiskā atmiņas piešķiršana valodā C/C++ attiecas uz programmētāja manuālu atmiņas piešķiršanu. Dinamiski piešķirtā atmiņa tiek piešķirta kaudze, un nestatiskajiem un vietējiem mainīgajiem tiek piešķirta atmiņa Kaudze (Atsaukties uz Atmiņas izkārtojuma C programmas sīkākai informācijai).

Kas ir lietojumprogrammas?

• Viens no dinamiski piešķirtās atmiņas izmantošanas veidiem ir mainīga izmēra atmiņas piešķiršana, kas nav iespējams ar kompilatora piešķirto atmiņu, izņemot mainīga garuma masīvi .
• Vissvarīgākais lietojums ir programmētājiem nodrošinātā elastība. Mēs varam brīvi piešķirt un atdalīt atmiņu, kad tā mums ir nepieciešama un kad tā vairs nav vajadzīga. Ir daudz gadījumu, kad šī elastība palīdz. Šādu gadījumu piemēri ir Koks utt.

Kā tas atšķiras no parastajiem mainīgajiem piešķirtās atmiņas?

Parastajiem mainīgajiem, piemēram, int a, char str[10] utt., atmiņa tiek automātiski piešķirta un atdalīta. Attiecībā uz dinamiski piešķirto atmiņu, piemēram, int *p = new int[10], programmētājs ir atbildīgs par atmiņas atdalīšanu, kad tā vairs nav nepieciešama. Ja programmētājs neatbrīvo atmiņu, tas izraisa a atmiņas noplūde (atmiņa netiek atbrīvota, kamēr programma netiek pārtraukta).

Kā atmiņa tiek piešķirta/atdalīta programmā C++?
C izmanto malloc () un calloc () funkcija, lai dinamiski piešķirtu atmiņu izpildes laikā, un izmanto funkciju free(), lai atbrīvotu dinamiski piešķirto atmiņu. C++ atbalsta šīs funkcijas, un tam ir arī divi operatori jauns un dzēst, kas veic atmiņas piešķiršanas un atbrīvošanas uzdevumu labāk un vienkāršāk.

jauns operators

Jaunais operators apzīmē pieprasījumu par atmiņas piešķiršanu Bezmaksas veikalā. Ja ir pieejama pietiekama atmiņa, jauns operators inicializē atmiņu un atgriež rādītāja mainīgajam tikko piešķirtās un inicializētās atmiņas adresi.

Sintakse, lai izmantotu jaunu operatoru

mikropakalpojumu apmācība

pointer-variable =   new   data-type;>

Šeit rādītāja mainīgais ir datu tipa rādītājs. Datu tips var būt jebkurš iebūvēts datu tips, tostarp masīvs, vai jebkurš lietotāja definēts datu tips, ieskaitot struktūru un klasi.
Piemērs:

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

Inicializēt atmiņu: Mēs varam arī inicializēt atmiņu iebūvētajiem datu tipiem, izmantojot jaunu operatoru. Pielāgotiem datu tipiem vērtības inicializācijai ir nepieciešams konstruktors (ar datu tipu kā ievadi). Šeit ir abu datu tipu inicializācijas piemērs:

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

Piemērs:

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

25 75.25 25>

Piešķiriet atmiņas bloku: jauns operators tiek izmantots arī, lai piešķirtu tipa atmiņas bloku (masīvu). datu tips .

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

kur izmērs (mainīgais) norāda elementu skaitu masīvā.

Piemērs:

amplitūdas modulācija

int *p = new int[10]>

Dinamiski piešķir atmiņu 10 veseliem skaitļiem, kuru tips ir int, un atgriež rādītāju uz pirmo secības elementu, kuram ir piešķirts augšējais (rādītājs). p[0] attiecas uz pirmo elementu, p[1] attiecas uz otro elementu un tā tālāk.

Parasta masīva deklarācija pret jaunu izmantošanu
Pastāv atšķirība starp parastā masīva deklarēšanu un atmiņas bloka piešķiršanu, izmantojot jaunu. Vissvarīgākā atšķirība ir tā, ka parastos masīvus atdala kompilators (ja masīvs ir lokāls, tad atdala, kad funkcija atgriežas vai tiek pabeigta). Tomēr dinamiski piešķirtie masīvi vienmēr paliek tur, līdz programmētājs tos atceļ, vai arī programma tiek pārtraukta.

Ko darīt, ja izpildlaikā nav pieejama pietiekami daudz atmiņas?
Ja kaudzē nav pietiekami daudz atmiņas, ko piešķirt, jaunais pieprasījums norāda uz kļūmi, izmetot izņēmumu, kura tips ir std::bad_alloc, ja vien ar jauno operatoru netiek izmantots nothrow, un tādā gadījumā tas atgriež NULL rādītāju (ritiniet līdz sadaļai Izņēmums jauna operatora apstrāde šis rakstu). Tāpēc pirms programmas izmantošanas ieteicams pārbaudīt rādītāja mainīgo, ko rada jaunā.

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

dzēst operatoru

Tā kā programmētājs ir atbildīgs par dinamiski piešķirtās atmiņas atdalīšanu, programmētājiem tiek nodrošināts dzēšanas operators C++ valodā.

Sintakse:

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

Šeit rādītāja mainīgais ir rādītājs, kas norāda uz izveidoto datu objektu jauns .

Piemēri:

delete p; delete q;>

Lai atbrīvotu dinamiski piešķirto masīvu, kas norādīts ar rādītāja mainīgo, izmantojiet šādu formu dzēst :

cilpai bash

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

Laika sarežģītība: O(n), kur n ir dotais atmiņas apjoms.

Saistītie raksti:

• Viktorīna par jaunu un dzēst
• dzēst vs bezmaksas