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,
- Szüksége van dinamikus memóriafoglalásra?
- Memória kiosztása új Kulcsszó
- A memória megosztása a töröl Kulcsszó
- Tömbök dinamikus kiosztása
- Dinamikus memóriaallokáció objektumokhoz
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:
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.