Hogyan működjön a dinamikus memóriaallokáció C ++?

Ez a cikk a dinamikus memóriaallokációt a C ++ verzióban tárja fel, amely egy fontos funkció, amely lehetővé teszi, hogy figyelembe vegye a valós idejű erőforrások memóriaigényét.

Dinamikus memóriaallokáció A C ++ alkalmazásban nagyon fontos funkció, amely lehetővé teszi, hogy figyelembe vegye a valós idejű erőforrások iránti igény kielégítését. Ebben a cikkben feltárnánk Részletes feltárás. A következő mutatókkal foglalkozunk ebben a cikkben,



Tehát kezdjük el a cikket a Dinamikus memóriaallokációról a C ++ nyelven



Szüksége van dinamikus memóriafoglalásra?

Mondjuk, egy mondatot karaktertömbként szeretnénk megadni, de nem vagyunk biztosak a tömbben szükséges pontos karakterek számában.

fibonacci szekvencia c ++ - ban

Most, a karaktertömb deklarálásakor, ha kisebb méretet adunk meg, mint a kívánt karakterlánc, akkor hibát fogunk kapni, mert a tömbhöz rendelt memória területe kisebb a bemeneti karakterlánc méretéhez képest. Ha nagyobb méretet adunk meg, mint a bemeneti karakterlánc mérete, akkor a tömb számára a memóriában egy olyan terület kerül kiosztásra, amely sokkal nagyobb, mint a kívánt karakterlánc mérete, így szükségtelenül több memóriát emészt fel, még akkor is, ha erre nincs szükség.



A fenti esetben a fordítás idejéig nincs elképzelésünk a tömb pontos méretéről (amikor a számítógép lefordítja a kódot, és a karakterláncot a felhasználó adja meg). Ilyen esetekben a új operátor.

A C ++ két unáris operátort határoz meg új és töröl amelyek végrehajtják a memória lefuttatásának és elosztásának feladatát futás közben. Mivel ezek az operátorok (új és törlés) a szabad tárhely memóriáján (kupac memória) működnek, ezeket szabad tároló operátoroknak is nevezik. A mutatók biztosítják a szükséges támogatást a dinamikus memória-allokációs rendszerhez C ++ nyelven.

A Dinamikus allokáció segítségével a program futás közben képes memóriát szerezni.



A globális és a helyi változókat lefordítják a memóriába fordítási idő alatt. Futás közben azonban nem adhatunk hozzá globális vagy lokális változókat. Ha a programnak változó memóriamennyiséget kell használnia, akkor futás közben kell kiosztanunk memóriát, szükség szerint. És természetesen itt a dinamikus allokációs rutinok szolgálhatják a célt.

A statikus memória-allokáció és a dinamikus memória-allokáció közötti különbségek:

Ez egy alapvető memóriaarchitektúra, amelyet bármely C ++ programhoz használnak:

Memória - Dinamikus memóriaallokáció - Edureka

Szükségünk lesz egy ilyen képre

A verem a statikus memória-elosztáshoz, a Heap pedig a dinamikus memória-allokációhoz használható, mindkettőt a számítógép RAM-jában tárolják.

Azok a változók, amelyek a veremben kerülnek kiosztásra, miközben a statikus memória-allokációt közvetlenül a memóriába tárolják, és ehhez a memóriához való hozzáférés nagyon gyors, a lefordítással a program fordításakor is foglalkoznak. Amikor egy függvény vagy egy módszer meghív egy másik függvényt, amely viszont meghívhat egy másik függvényt, és így tovább, mindezen függvények végrehajtása felfüggesztve marad, amíg a legutolsó függvény vissza nem adja az értékét. A verem mindig LIFO (last in first out) sorrendben van tárolva, a legutóbb lefoglalt blokk mindig a következő felszabadítandó blokk. Ez segít a verem nyomon követésében, egy blokk felszabadítása a veremből nem más, mint egy mutató beállítása.

A halomon allokált változók memóriája futási időben, míg a dinamikus memória-allokáció van lefoglalva. Ehhez a memóriához kissé lassabban lehet hozzáférni, mint a veremben, de a halom méretét csak a virtuális memória mérete korlátozza. A halom elemének nincsenek függőségei egymással, és bármikor véletlenszerűen elérhető, bármikor. Bármikor kioszthatunk egy blokkot, és bármikor felszabadíthatjuk. Ez megnehezíti annak nyomon követését, hogy a kupac mely részei kerülnek kiosztásra vagy egy adott időpontra.

Folytatás ezzel a cikkel: Dinamikus memóriaallokáció a C ++ nyelven

Memória kiosztása új Kulcsszó

A C ++ - ban a új operátort használnak memória lefoglalására futás közben, és a memóriát bájtokban osztják ki. Az új operátor a halom dinamikus memória-allokációjának kérését jelöli. Ha elegendő memória áll rendelkezésre, akkor a új az operátor inicializálja a memóriát, és visszaadja az újonnan lefoglalt és inicializált memória címét a mutató változónak.

Szintaxis:

adattípus * pointer_name = új adattípus

Példa:

int * ptr = new int // Változót a dinamikus allokáció során a következő két módon deklarálhatunk. int * ptr = new int (10) int * ptr = new int {15} // új operátort adattípusú memóriablokk (tömb) lefoglalására is használunk. int * ptr = new int [20] // A fenti utasítás dinamikusan lefoglalja a memóriát 20 egész típusú, folyamatosan int típusú memóriának, és egy mutatót ad vissza a szekvencia első elemének a „ptr” mutatóba.

jegyzet : Ha a halomnak nincs elegendő memóriája a lefoglaláshoz, akkor az új kérés sikertelenséget jelez az std :: bad_alloc kivétel dobásával, hacsak az új operátorral nem használjuk a „nothrow” szót, amely esetben NULL mutatót ad vissza. Ezért jó gyakorlat, ha a programban való felhasználás előtt ellenőrizzük az new által létrehozott mutatóváltozót.

Folytatás ezzel a cikkel: Dinamikus memóriaallokáció a C ++ nyelven

A memória megosztása a töröl Kulcsszó:

Miután a halom memóriát lefoglaltuk egy változónak vagy osztályobjektumnak a új kulcsszó, akkor a memóriaterületet a töröl kulcsszó.

Szintaxis:

pointer_variable törlése // Itt a pointer_variable az a mutató, amely az új által létrehozott adatobjektumra mutat. delete [] pointer_variable // A mutató-változó által mutatott dinamikusan lefoglalt tömb memória felszabadításához a következő törlési formát használjuk:

Példa:

törlés ptr törlés [] ptr

jegyzet : Az objektum kiterjedése vagy az objektum élettartama az az idő, amelyig az objektum a program végrehajtása során a memóriában marad. A kupac memória lefoglalása lassabb, mint a verem, mivel a kupacban nincs külön sorrend, amelyben a memóriát lefoglalhatja, míg a veremben a LIFO-t követi.

Folytatás ezzel a cikkel: Dinamikus memóriaallokáció a C ++ nyelven

Tömbök dinamikus kiosztása

A dinamikus memória-allokáció fogalmának fő célja a memória lefoglalása egy tömb számára, amikor deklarálnunk kell a méretének megadásával, de nem vagyunk biztosak benne.

Lássunk egy példát a használatának megértésére.

#include névtér használatával std int main () {int len, sum = 0 cout<< 'Enter the no. of students in the class' <>len int * mark = új int [len] // Dinamikus memória-allokációs cout<< 'Enter the marks of each student' << endl for( int i = 0 i>* (jelek + i)} (int i = 0 i

Magyarázat:
Ebben a példában először a felhasználótól kérdezzük meg az osztály tanulóinak számát, és az értékét eltároljuk a len változóban. Ezután deklarálunk egy egész tömböt, és dinamikusan megegyezünk vele a memóriában a len változóban tárolt értékkel, ezzel az int * marks = new int [length] utasítással, így a „length * (1 egész szám)'. A kód többi része magától értetődő.

Folytatás ezzel a cikkel: Dinamikus memóriaallokáció a C ++ nyelven

Dinamikus memóriaallokáció objektumokhoz

Dinamikusan lefoglalhatunk objektumokat is.

Mint tudjuk, hogy a Constructor egy speciális osztálytag-függvény, amelyet egy objektum inicializálására használnak, és a Destructor is osztálytag-függvény, amelyet akkor hívnak meg, amikor az objektum kilép a hatóköréből.

A Destructor használható az objektumhoz rendelt memória felszabadítására. A következő feltételekkel hívják meg.

  • Amikor egy helyi objektum kimarad a hatókörből
  • Globális objektum esetén, amikor egy operátort alkalmaznak az osztály objektumának mutatójára

Ismét használhatunk mutatókat, miközben dinamikusan osztjuk ki a memóriát az objektumoknak.

Lássunk egy példát egy tömb objektumra.

#include névtér használatával std osztály Véletlenszerű {public: Random () {cout<< 'Constructor' << endl } ~Random() { cout << 'Destructor' << endl } } int main() { Random* a = new Random[3] delete [] a // Delete array return 0 } 

Kimenet:

chef vs ansible vs báb

Magyarázat:

A Konstruktort háromszor hívják meg, mivel a Random osztály három objektumához rendelünk memóriát. A rombolót ezen objektumok során is háromszor hívják. ‘Random * a = new Random [3]’ ez a kijelentés felelős az objektumunk dinamikus memória-allokációjáért.

Így a „Dinamikus memóriaallokáció C ++” című cikkünk végéhez értünk. Ha többet szeretne megtudni, nézze meg a Edureka, egy megbízható online tanulási társaság. Az Edureka Java J2EE és SOA képzési és tanúsítási tanfolyamát arra tervezték, hogy mind az alapvető, mind a fejlett Java koncepciókra kiképezzen különféle Java keretrendszereket, például a Hibernate & Spring.

Van egy kérdésünk? Kérjük, említse meg a blog megjegyzés rovatában, és a lehető leghamarabb kapcsolatba lépünk Önnel.