Ang Dynamic Memory Allocation Sa C ++ ay isang napakahalagang tampok na hinahayaan kang isaalang-alang ang iyong mga kinakailangan upang harapin ang pangangailangan para sa mga mapagkukunang real time. Sa artikulong ito nais naming tuklasin Detalye ng paggalugad. Saklaw ang artikulong ito sa artikulong ito,
- Kailangan para sa Dynamic na paglalaan ng memorya?
- Paglalaan ng Memory gamit ang bago Keyword
- Deallocation ng memorya gamit ang tanggalin Keyword
- Dynamically Allocating Arrays
- Dynamic na Pag-alok ng Memory para sa Mga Bagay
Kaya't magsimula tayo sa artikulong ito sa Dynamic Memory Allocation sa C ++
Kailangan para sa Dynamic na paglalaan ng memorya?
Sabihin nating, nais naming maglagay ng isang pangungusap bilang isang hanay ng mga character ngunit hindi kami sigurado tungkol sa eksaktong bilang ng mga character na kinakailangan sa array.
Ngayon, habang idinedeklara ang character array, kung tinukoy namin ang laki nito na mas maliit kaysa sa laki ng nais na string, magkakaroon kami ng isang error dahil ang puwang sa memorya na inilalaan sa array ay mas mababa kumpara sa laki ng input string. Kung tinukoy namin ang laki nito na mas malaki kaysa sa laki ng input string, pagkatapos ang array ay ilalaan ng isang puwang sa memorya na mas malaki kaysa sa laki ng nais na string, kaya't hindi kinakailangang ubusin ang mas maraming memorya kahit na hindi ito kinakailangan.
Sa kaso sa itaas, wala kaming ideya tungkol sa eksaktong sukat ng array hanggang sa oras ng pagtitipon (kapag pinagsama-sama ng computer ang code at ang string ay nai-input ng gumagamit). Sa mga ganitong kaso, ginagamit namin ang bago operator
Tinukoy ng C ++ ang dalawang unary operator bago at tanggalin na gampanan ang gawain ng paglalaan at deallocating memorya sa panahon ng runtime. Dahil ang mga operator na ito (bago at tanggalin) ay nagpapatakbo sa memorya ng libreng tindahan (Heap memory), tinatawag din silang operator ng libreng tindahan. Nagbibigay ang mga pointer ng kinakailangang suporta para sa sistema ng paglalaan ng pabagu-bago ng memorya sa C ++.
Sa tulong ng Dynamic Allocation, ang isang programa ay maaaring makakuha ng memorya sa panahon ng runtime.
Ang pandaigdigan at lokal na mga variable ay inilalaan sa memorya sa panahon ng compile-time. Gayunpaman, hindi kami maaaring magdagdag ng anumang pandaigdigan o lokal na mga variable sa panahon ng runtime. Kung ang programa ay kailangang gumamit ng isang variable na halaga ng memorya kakailanganin naming maglaan ng memorya sa panahon ng runtime, kung kailan kinakailangan. At syempre, dito maaaring maihatid ng layunin ang mga nakagawiang gawain sa paglalaan.
Mga pagkakaiba sa pagitan ng Static memory memory at Dynamic memory allocation:
Ito ay isang pangunahing arkitektura ng memorya na ginamit para sa anumang programa ng C ++:
Kakailanganin namin ang isang imaheng tulad nito
Ginagamit ang stack para sa static na alokasyon ng memorya at Heap para sa pabagu-bagong alokasyon ng memorya, kapwa nakaimbak sa RAM ng computer.
Ang mga variable na inilalaan sa stack habang ang static na paglalaan ng memorya ay nakaimbak nang direkta sa memorya at ang pag-access sa memorya na ito ay napakabilis, ang paglalaan din nito ay haharapin kapag ang programa ay naipon. Kapag ang isang pagpapaandar o isang pamamaraan ay tumatawag ng isa pang pagpapaandar na maaaring tumawag sa isa pang pag-andar at iba pa, ang pagpapatupad ng lahat ng mga pagpapaandar na ito ay mananatiling nasuspinde hanggang sa maibalik ang huling pag-andar nito. Ang stack ay palaging nakaimbak sa isang order ng LIFO (huling sa unang labas), ang pinakahuling nakareserba na bloke ay palaging ang susunod na bloke upang mapalaya. Nakakatulong ito upang subaybayan ang stack, ang libreng isang bloke mula sa stack ay hindi hihigit sa pag-aayos ng isang pointer.
Ang mga variable na inilalaan sa bunton ay inilalaan ang kanilang memorya sa oras ng pagtakbo habang ang paglalaan ng memorya ng memorya. Ang pag-access sa memorya na ito ay medyo mas mabagal kumpara sa stack, ngunit ang laki ng magbunton ay limitado lamang sa laki ng virtual memory. Ang elemento ng bunton ay walang mga dependency sa bawat isa at maaaring palaging ma-access nang sapalaran sa anumang sandali ng oras. Maaari kaming maglaan ng isang bloke sa anumang oras at palayain ito sa anumang oras. Pinahihirapan ito upang subaybayan kung aling mga bahagi ng tambak ang inilalaan o nakipag-deallocate sa anumang naibigay na oras.
Nagpapatuloy sa artikulong ito sa Dynamic Memory Allocation sa C ++
Paglalaan ng Memory gamit ang bago Keyword
Sa C ++ ang bago Ginagamit ang operator upang maglaan ng memorya sa runtime at ang memorya ay inilalaan sa mga byte. Ang bago ang operator ay nagpapahiwatig ng isang kahilingan para sa pabagu-bago ng memorya ng alok sa Heap. Kung ang sapat na memorya ay magagamit pagkatapos ang bago pinasimulan ng operator ang memorya at ibabalik ang address ng bagong inilalaan at inisyal na memorya sa variable ng pointer.
Syntax:
datatype * pointer_name = bagong datatype
Halimbawa:
int * ptr = bagong int // Maaari naming ideklara ang isang variable habang ang dinamikong paglalaan sa mga sumusunod na dalawang paraan. int * ptr = bagong int (10) int * ptr = bagong int {15} // bagong operator ay ginagamit din upang maglaan ng isang bloke (isang array) ng memorya ng uri ng data-type. int * ptr = bagong int [20] // Ang pahayag sa itaas ay palaging naglalaan ng memorya para sa 20 integer na tuloy-tuloy na uri ng int at nagbabalik ng isang pointer sa unang elemento ng pagkakasunud-sunod sa 'ptr' pointer.Tandaan : Kung ang bunton ay walang sapat na memorya upang ilaan, ang bagong kahilingan ay nagpapahiwatig ng kabiguan sa pamamagitan ng pagkahagis ng isang eksepsyon std :: bad_alloc, maliban kung ginamit ang 'nothrow' sa bagong operator, kung saan ito ay nagbabalik ng isang NULL pointer. Samakatuwid, isang mahusay na kasanayan upang suriin para sa variable ng pointer na ginawa ng bago bago gamitin ito sa programa.
Nagpapatuloy sa artikulong ito sa Dynamic Memory Allocation sa C ++
kung paano maging isang artipisyal na inhinyero ng katalinuhan
Deallocation ng memorya gamit ang tanggalin Keyword:
Sa sandaling magbunton ng memorya ay inilalaan sa isang variable o klase ng object gamit ang bago keyword, maaari naming iaksyunan ang puwang ng memorya na iyon gamit ang tanggalin keyword.
Syntax:
tanggalin ang pointer_variable // Dito, pointer_variable ay ang pointer na tumuturo sa data object na nilikha ng bago. tanggalin ang [] pointer_variable // Upang mapalaya ang pabagu-bago na inilalaan na memorya ng array na itinuro ng pointer-variable ginagamit namin ang sumusunod na form ng pagtanggal:
Halimbawa:
tanggalin ang ptr tanggalin [] ptr
Tandaan : Ang lawak ng object o habang buhay ng object ay ang oras kung saan mananatili ang bagay sa memorya habang naisakatuparan ang programa. Ang paglalaan ng Heap Memory ay mas mabagal kaysa sa isang stack, dahil, sa tambak, walang partikular na pagkakasunud-sunod kung saan maaari kang maglaan ng memorya samantalang sa stack sinusunod nito ang LIFO.
Nagpapatuloy sa artikulong ito sa Dynamic Memory Allocation sa C ++
Dynamically Allocating Arrays
Ang pangunahing paggamit ng konsepto ng paglalaan ng memorya ng memorya ay para sa paglalaan ng memorya sa isang array kapag kailangan naming ideklara ito sa pamamagitan ng pagtukoy sa laki nito ngunit hindi sigurado tungkol dito.
Tingnan natin, isang halimbawa upang maunawaan ang paggamit nito.
# isama ang paggamit ng namespace std int main () {int len, sum = 0 cout<< 'Enter the no. of students in the class' <>mga marka ng len int * = bagong int [len] // Dynamic na paglalaan ng memory cout<< 'Enter the marks of each student' << endl for( int i = 0 i>* (marka + i)} para sa (int i = 0 i Paliwanag:
Sa halimbawang ito unang tinanong namin ang gumagamit para sa bilang ng mga mag-aaral sa isang klase at iniimbak namin ang halaga nito sa len variable. Pagkatapos ay idineklara namin ang isang hanay ng integer at inilalaan ito ng puwang sa memorya na pabago-pantay na katumbas ng halaga na nakaimbak sa variable ng len gamit ang pahayag na ito int * marka = bagong int [haba] sa gayon ito ay inilalaan ng isang puwang na katumbas ng 'haba * (laki ng 1 integer) '. Ang natitirang code ay nagpapaliwanag sa sarili.
Nagpapatuloy sa artikulong ito sa Dynamic Memory Allocation sa C ++
Dynamic na Pag-alok ng Memory para sa Mga Bagay
Maaari din nating mailalaan ang mga object.
Tulad ng nalalaman natin na ang Bumuo ng isang espesyal na pagpapaandar ng miyembro ng klase na ginagamit upang pasimulan ang isang bagay at ang Destructor ay isang pagpapaandar din ng miyembro ng klase na tinatawag tuwing lumalabas sa saklaw ang bagay.
Ang Destructor ay maaaring magamit upang palabasin ang memorya na nakatalaga sa object. Tinawag ito sa mga sumusunod na kundisyon.
pinakamahusay na java ide para sa windows
- Kapag ang isang lokal na bagay ay napupunta sa labas ng saklaw
- Para sa isang pandaigdigang bagay, kapag ang isang operator ay inilalapat sa isang pointer sa object ng klase
Maaari naming magamit muli ang mga payo habang pabagu-bago ng paglalaan ng memorya sa mga bagay.
Tingnan natin ang isang halimbawa ng isang hanay ng mga bagay.
# isama ang paggamit ng namespace std class Random {public: Random () {cout<< 'Constructor' << endl } ~Random() { cout << 'Destructor' << endl } } int main() { Random* a = new Random[3] delete [] a // Delete array return 0 } Output:
Paliwanag:
Tatawag ng tatlong beses ang Tagabuo dahil naglalaan kami ng memorya sa tatlong mga bagay ng klase na Random. Tatawagin din ang Destructor ng tatlong beses sa bawat isa sa mga bagay na ito. ‘Random * a = bagong Random [3]’ ang pahayag na ito ay responsable para sa pabagu-bago ng memorya ng aming object.
Sa gayon ay natapos na kami sa artikulong ito sa 'Dynamic Memory Allocation C ++'. Kung nais mong matuto nang higit pa, tingnan ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online. Ang kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo upang sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring.
May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng blog na ito at babalikan ka namin sa lalong madaling panahon.