Alocarea dinamică a memoriei în C ++ este o caracteristică foarte importantă care vă permite să luați în considerare cerințele dvs. pentru a face față nevoii de resurse în timp real. În acest articol am fi explorat Explorare în detaliu. Următorii indicatori vor fi acoperiți în acest articol,
- Aveți nevoie de alocare dinamică a memoriei?
- Alocarea memoriei folosind nou Cuvânt cheie
- Alocarea memoriei utilizând șterge Cuvânt cheie
- Alocarea dinamică a matricelor
- Alocarea dinamică a memoriei pentru obiecte
Deci, haideți să începem cu acest articol despre Alocarea dinamică a memoriei în C ++
Aveți nevoie de alocare dinamică a memoriei?
Să presupunem că vrem să introducem o propoziție ca o matrice de caractere, dar nu suntem siguri de numărul exact de caractere necesar în matrice.
Acum, în timp ce declarăm matricea de caractere, dacă îi specificăm dimensiunea mai mică decât dimensiunea șirului dorit, atunci vom primi o eroare deoarece spațiul din memorie alocat matricei este mai mic în comparație cu dimensiunea șirului de intrare. Dacă îi specificăm dimensiunea mai mare decât dimensiunea șirului de intrare, atunci matricei i se va aloca un spațiu în memorie care este mult mai mare decât dimensiunea șirului dorit, consumând astfel inutil mai multă memorie chiar și atunci când nu este necesară.
În cazul de mai sus, nu avem ideea despre dimensiunea exactă a matricei până la momentul compilării (când computerul compilează codul și șirul este introdus de utilizator). În astfel de cazuri, folosim nou operator.
C ++ definește doi operatori unari nou și șterge care îndeplinesc sarcina de alocare și repartizare a memoriei în timpul rulării. Deoarece acești operatori (noi și șterși) funcționează cu memorie de stocare gratuită (memorie Heap), aceștia sunt numiți și operator de magazin gratuit. Pointerii oferă suportul necesar pentru sistemul de alocare dinamică a memoriei în C ++.
Cu ajutorul Alocării dinamice, un program poate obține memorie în timpul rulării.
Variabilele globale și locale sunt alocate memoriei în timpul compilării. Cu toate acestea, nu putem adăuga nicio variabilă globală sau locală în timpul rulării. Dacă programul trebuie să utilizeze o cantitate variabilă de memorie, ar trebui să alocăm memorie în timpul rulării, după cum și când este necesar. Și, desigur, aici rutinele de alocare dinamică pot servi scopului.
java matrice de obiecte exemplu
Diferențele dintre alocarea de memorie statică și alocarea dinamică a memoriei:
Aceasta este o arhitectură de memorie de bază utilizată pentru orice program C ++:
Vom avea nevoie de o imagine ca aceasta
Stiva este utilizată pentru alocarea de memorie statică și Heap pentru alocarea dinamică a memoriei, ambele sunt stocate în memoria RAM a computerului.
Variabilele care sunt alocate pe stivă în timp ce alocarea de memorie statică este stocată direct în memorie și accesul la această memorie este foarte rapid, de asemenea, alocarea sa este tratată atunci când programul este compilat. Atunci când o funcție sau o metodă apelează o altă funcție care la rândul său ar putea apela o altă funcție și așa mai departe, executarea tuturor acestor funcții rămâne suspendată până când ultima funcție își returnează valoarea. Stiva este întotdeauna stocată într-o ordine LIFO (ultima în prima ieșire), cel mai recent bloc rezervat este întotdeauna următorul bloc care trebuie eliberat. Acest lucru ajută la urmărirea stivei, eliberarea unui bloc din stivă nu este altceva decât ajustarea unui pointer.
Variabilele alocate pe heap au memoria lor alocată în timpul rulării în timp ce alocarea dinamică a memoriei. Accesul la această memorie este puțin mai lent în comparație cu stiva, dar dimensiunea heap-ului este limitată doar de dimensiunea memoriei virtuale. Elementul heap-ului nu are dependențe între ele și poate fi accesat întotdeauna aleatoriu în orice moment al timpului. Putem aloca un bloc în orice moment și îl putem elibera în orice moment. Acest lucru face dificilă urmărirea părților din heap care sunt alocate sau alocate la un moment dat.
Continuăm cu acest articol despre Alocarea dinamică a memoriei în C ++
Alocarea memoriei folosind nou Cuvânt cheie
În C ++ nou operatorul este utilizat pentru a aloca memorie în timpul rulării și memoria este alocată în octeți. nou operatorul denotă o cerere de alocare dinamică a memoriei pe Heap. Dacă este disponibilă suficientă memorie, atunci nou operatorul inițializează memoria și returnează adresa memoriei nou alocate și inițializate variabilei pointer.
Sintaxă:
tip de date * pointer_name = tip de date nou
Exemplu:
int * ptr = new int // Putem declara o variabilă în timp ce alocarea dinamică în următoarele două moduri. int * ptr = new int (10) int * ptr = new int {15} // noul operator este, de asemenea, utilizat pentru a aloca un bloc (o matrice) de memorie de tip date. int * ptr = new int [20] // Instrucțiunea de mai sus alocă dinamic memoria pentru 20 de numere întregi continuu de tip int și returnează un pointer la primul element al secvenței la pointerul ‘ptr’.Notă : Dacă heap-ul nu are suficientă memorie pentru a aloca, noua cerere indică eșecul aruncând o excepție std :: bad_alloc, cu excepția cazului în care „nothrow” este utilizat cu noul operator, caz în care returnează un pointer NULL. Prin urmare, este o practică bună să verificați variabila pointer produsă de new înainte de a o utiliza în program.
Continuăm cu acest articol despre Alocarea dinamică a memoriei în C ++
Alocarea memoriei utilizând șterge Cuvânt cheie:
Odată ce memoria heap este alocată unei variabile sau unui obiect de clasă utilizând nou cuvânt cheie, putem să alocăm acel spațiu de memorie folosind șterge cuvânt cheie.
Sintaxă:
șterge pointer_variable // Aici, pointer_variable este indicatorul care indică obiectul de date creat de new. delete [] pointer_variable // Pentru a elibera memoria matricei alocate dinamic indicată de pointer-variable utilizăm următoarea formă de ștergere:
Exemplu:
delete ptr delete[] ptr
Notă : Mărimea obiectului sau durata de viață a obiectului este timpul pentru care obiectul rămâne în memorie în timpul executării programului. Alocarea memoriei Heap este mai lentă decât o stivă, deoarece, în heap, nu există o ordine specială în care să puteți aloca memorie, în timp ce în stivă urmează LIFO.
Continuăm cu acest articol despre Alocarea dinamică a memoriei în C ++
Alocarea dinamică a matricelor
Utilizarea majoră a conceptului de alocare dinamică a memoriei este pentru alocarea memoriei la o matrice atunci când trebuie să o declarăm specificând dimensiunea acesteia, dar nu suntem siguri de aceasta.
Să vedem, un exemplu pentru a înțelege utilizarea acestuia.
#includeți utilizarea spațiului de nume std int main () {int len, sum = 0 cout<< 'Enter the no. of students in the class' <>len int * marks = new int [len] // Alocare dinamică a memoriei cout<< 'Enter the marks of each student' << endl for( int i = 0 i>* (marchează + i)} pentru (int i = 0 i Explicaţie:
În acest exemplu, mai întâi cerem utilizatorului numărul de elevi dintr-o clasă și stocăm valoarea acestuia în variabila len. Apoi declarăm o matrice de numere întregi și îi alocăm spațiu în memorie dinamic egal cu valoarea stocată în variabila len folosind această instrucțiune int * marks = new int [length] astfel că i se alocă un spațiu egal cu 'length * (dimensiunea 1 întreg)'. Restul codului se explică de la sine.
Continuăm cu acest articol despre Alocarea dinamică a memoriei în C ++
Alocarea dinamică a memoriei pentru obiecte
De asemenea, putem aloca obiecte dinamic.
După cum știm că Constructor este o funcție specială de membru de clasă utilizată pentru a inițializa un obiect și Destructor este, de asemenea, o funcție de membru de clasă, care se numește ori de câte ori obiectul iese din sfera de aplicare.
Destructor poate fi folosit pentru a elibera memoria atribuită obiectului. Se numește în următoarele condiții.
- Când un obiect local iese din scop
- Pentru un obiect global, atunci când un operator este aplicat unui pointer la obiectul clasei
Putem folosi din nou pointeri în timp ce alocăm dinamic memorie obiectelor.
Să vedem un exemplu de matrice de obiecte.
#includeți utilizarea spațiului de nume clasa std Aleatoriu {public: Random () {cout<< 'Constructor' << endl } ~Random() { cout << 'Destructor' << endl } } int main() { Random* a = new Random[3] delete [] a // Delete array return 0 } Ieșire:
Explicaţie:
Constructorul va fi apelat de trei ori, deoarece alocăm memorie la trei obiecte din clasa Random. Destructorul va fi, de asemenea, chemat de trei ori în timpul fiecăruia dintre aceste obiecte. „Random * a = new Random [3]” această declarație este responsabilă pentru alocarea dinamică a memoriei obiectului nostru.
Astfel am ajuns la sfârșitul acestui articol despre „Dynamic Memory Allocation C ++”. Dacă doriți să aflați mai multe, consultați de Edureka, o companie de învățare online de încredere. Cursul de formare și certificare Java J2EE și SOA al Edureka este conceput pentru a vă instrui atât pentru conceptele Java de bază, cât și pentru cele avansate, împreună cu diverse cadre Java, cum ar fi Hibernate & Spring.
Ai o întrebare pentru noi? Vă rugăm să o menționați în secțiunea de comentarii a acestui blog și vă vom răspunde cât mai curând posibil.
tutorial mvc de primăvară pentru începători