Dynaaminen muistin varaus C/C++:ssa tarkoittaa ohjelmoijan manuaalista muistin varaamista. Dynaamisesti varattu muisti on varattu Pino, ja ei-staattiset ja paikalliset muuttujat saavat muistia Pino (Viitata Muistin asettelu C-ohjelmat yksityiskohtia varten).

Mitä sovellukset ovat?

• Eräs dynaamisesti varatun muistin käyttötapa on vaihtelevan kokoisen muistin varaaminen, mikä ei ole mahdollista kääntäjälle varatulla muistilla paitsi muuttuvapituisia taulukoita .
• Tärkein käyttötarkoitus on ohjelmoijille tarjottu joustavuus. Olemme vapaita allokoimaan ja jakamaan muistia aina, kun tarvitsemme sitä ja milloin emme enää tarvitse sitä. On monia tapauksia, joissa tämä joustavuus auttaa. Esimerkkejä tällaisista tapauksista ovat Puu , jne.

Miten se eroaa normaaleille muuttujille varatusta muistista?

Tavallisille muuttujille, kuten int a, char str[10] jne., muisti varataan ja vapautetaan automaattisesti. Dynaamisesti varatulle muistille, kuten int *p = uusi int[10], on ohjelmoijan vastuulla vapauttaa muisti, kun sitä ei enää tarvita. Jos ohjelmoija ei vapauta muistia, se aiheuttaa a muistivuoto (muistia ei vapauteta ennen kuin ohjelma päättyy).

Kuinka muisti varataan/vapautetaan C++:ssa?
C käyttää malloc() ja calloc() funktio varaamaan muistia dynaamisesti ajon aikana ja käyttää free()-funktiota dynaamisesti varatun muistin vapauttamiseen. C++ tukee näitä toimintoja ja siinä on myös kaksi operaattoria Uusi ja poistaa, jotka suorittavat muistin varaamisen ja vapauttamisen paremmin ja helpommin.

uusi operaattori

Uusi operaattori tarkoittaa muistinvarauspyyntöä Free Storessa. Jos muistia on riittävästi, uusi operaattori alustaa muistin ja palauttaa juuri varatun ja alustetun muistin osoitteen osoitinmuuttujalle.

Syntaksi uuden operaattorin käyttöön

huffman koodauskoodi

pointer-variable =   new   data-type;>

Tässä osoitinmuuttuja on datatyypin osoitin. Tietotyyppi voi olla mikä tahansa sisäänrakennettu tietotyyppi, mukaan lukien taulukko, tai mikä tahansa käyttäjän määrittämä tietotyyppi, mukaan lukien rakenne ja luokka.
Esimerkki:

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

Alusta muisti: Voimme myös alustaa muistin sisäänrakennetuille tietotyypeille käyttämällä uutta operaattoria. Mukautetuissa tietotyypeissä tarvitaan konstruktori (tietotyyppi syötteenä) arvon alustamiseksi. Tässä on esimerkki molempien tietotyyppien alustamisesta:

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

Esimerkki:

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

25 75.25 25>

Varaa muistilohko: uutta operaattoria käytetään myös varaamaan tyyppinen muistilohko (taulukko). tietotyyppi .

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

jossa koko(muuttuja) määrittää taulukon elementtien määrän.

Esimerkki:

binääripuun läpikulku

int *p = new int[10]>

Varaa dynaamisesti muistia 10 kokonaisluvulle, joiden tyyppi on int, ja palauttaa osoittimen sekvenssin ensimmäiseen elementtiin, joka on määritetty top(osoitin). p[0] viittaa ensimmäiseen elementtiin, p[1] viittaa toiseen elementtiin ja niin edelleen.

Normaali taulukon ilmoitus vs. uuden käyttäminen
Normaalin taulukon ilmoittamisen ja muistilohkon varaamisen välillä on ero. Tärkein ero on, että kääntäjä vapauttaa normaalit taulukot (jos taulukko on paikallinen, se puretaan, kun funktio palaa tai valmistuu). Dynaamisesti allokoidut taulukot pysyvät kuitenkin aina siellä, kunnes ohjelmoija on vapauttanut ne tai ohjelma päättyy.

Entä jos muistia ei ole tarpeeksi käytettävissä ajon aikana?
Jos kasassa ei ole tarpeeksi muistia varattavaksi, uusi pyyntö osoittaa epäonnistumisen heittämällä poikkeuksen tyyppiä std::bad_alloc, ellei nothrow ole käytössä uuden operaattorin kanssa, jolloin se palauttaa NULL-osoittimen (vieritä kohtaan Poikkeus uuden operaattorin käsittely Tämä artikla). Siksi voi olla hyvä idea tarkistaa uuden tuottama osoitinmuuttuja ennen sen ohjelman käyttöä.

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

poista operaattori

Koska ohjelmoijan vastuulla on vapauttaa dynaamisesti varattu muisti, ohjelmoijat saavat poisto-operaattorin C++-kielellä.

Syntaksi:

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

Tässä osoitinmuuttuja on osoitin, joka osoittaa luomaan tietoobjektiin Uusi .

Esimerkkejä:

harmaa koodi

delete p; delete q;>

Voit vapauttaa osoitinmuuttujan osoittaman dynaamisesti allokoidun taulukon käyttämällä seuraavaa muotoa poistaa :

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

Aika monimutkaisuus: O(n), missä n on annettu muistin koko.

Aiheeseen liittyvät artikkelit:

• Testaa uusia ja poista
• poista vs ilmainen