Samantalang, sa pabago-bagong paglalaan ng memorya, ang memorya ay inilalaan habang nagsimula ang pagpapatupad. Ang memorya na ito ay manu-manong inilalaan ng programmer sa run-time, na kilala rin bilang isang run-time na paglalaan ng memorya sa C++. Ang laki ng dynamic na memorya ay maaaring baguhin sa anumang posisyon sa programa dahil sa oras ng deklarasyon, hindi namin binanggit ang isang sukat na maaaring maayos. Direktang ibinibigay namin ang halaga sa variable.
Pagkakaiba ng paglalaan ng memorya sa mga normal na variable
Sa normal na mga variable, ang memorya na inilalaan ng isang compiler ay inilalaan at awtomatikong na-deallocate. Kapag ang memorya ay dynamic na inilalaan ng programmer, pagkatapos ay kailangan niyang tanggalin o i-deallocate ang memory kapag ito ay walang silbi sa karagdagang pagpapatupad ng source code. Ang sitwasyong ito ay nagdudulot ng 'memory leak' kapag ang programa ay winakasan habang ang memorya ay hindi na-deallocate.
Mga operator para sa dynamic na alokasyon
Sa C++, dalawang operator ang tumutulong sa memory allocation at deallocation: 'bago' at 'delete' na ginagamit para sa allocation at deallocation ng memory sa isang mas mahusay na paraan.
Bagong operator
Ito ay nagpapahiwatig ng pangangailangan para sa paglalaan ng memorya. Pinasimulan ng bagong operator ang memorya at ibinabalik ang address ng nakalaan na memorya sa variable ng pointer kung mayroong sapat na memorya na magagamit.
Pointer object = bago datos - uri ;
Tanggalin ang operator
Katulad ng bagong operator, ginagamit ang delete operator para tanggalin ang nakalaan na memorya. Sa C++, maaaring gamitin ng programmer ang operator na ito para sa deallocation.
# Tanggalin ang pointer_variable;
Halimbawa 1
Sa halimbawang ito, ipapakilala namin ang dalawang pointer: ang isa ay isang integer type pointer at ang isa ay isang float pointer. Sinisimulan ang mga pointer sa pamamagitan ng paggamit ng asterisk sign sa kanila.
# Int * pointInt;# Lutang *pointfloat;
Sa pamamagitan ng paggamit ng dalawang printer na ito, dynamic naming ilalaan ang memorya.
Tungkulin ng mga pointer sa dynamic na alokasyon:
Ang memorya ng espasyo sa imbakan ay binuo sa anyo ng mga bloke. Sa tuwing nagpapatupad kami ng isang programa o nagsasagawa ng anumang operasyon, ang memorya ay inilalaan para sa partikular na layunin. Ang memorya na iyon ay may espesyal na address na nauugnay sa program na tumutukoy kung aling proseso o programa ang pinapayagan sa memorya na iyon. Ang anumang memory slot ay naa-access sa pamamagitan ng address kung saan ito nabibilang. Kaya ang address na ito ay nakaimbak sa pamamagitan ng mga pointer. Sa madaling salita, kailangan namin ng mga pointer upang ma-access ang memorya at sa parehong paraan, upang maglaan ng isang partikular na bahagi ng memorya sa anumang gawain. Kailangan ng mga pointer upang mag-imbak ng mga address.
Dahil ang 'bago' na keyword ay ginagamit para sa dynamic na alokasyon ng memorya sa manu-manong paglalaan, ang memorya ay inilalaan ng compiler. Hindi namin kailangang maglaan ng memorya sa oras ng pagtakbo. Ngunit dahil random ang dynamic na alokasyon, kailangan nating tukuyin ang mga pointer at para sa proseso ng pagbubuklod, ginagamit ang bagong operator na ito.
# Pointint = bagong int;Katulad nito, ang lumulutang na pointer ay nakatali din. Pagkatapos ng proseso ng pagbubuklod, magtatalaga kami ng anumang halaga sa memorya na gusto naming i-book para sa anumang operasyon. Sa pamamagitan ng pagdedeklara ng pointer, nagtatalaga kami ng isang tiyak na halaga sa memorya.
# *pointInt = 50;Ang isang float value para sa mga point float ay ipinahayag din. Ipakita ang mga halaga pagkatapos magtalaga.
Tulad ng napag-usapan natin, ang 'bagong' operator ay ginagamit upang maglaan habang ang 'tanggalin' ay ginagamit upang mag-deallocate ng memorya. Kaya kapag nakumpleto mo na ang gawain o operasyon sa code, aalisin namin ang memorya na inilaan namin sa gawain.
Mas mainam na i-deallocate ang bahaging iyon ng memorya para mapakinabangan ito ng anumang ibang proseso. Ilalapat namin ang alokasyong ito sa parehong mga pointer.
Tanggalin ang punto lumutang ; 
Kapag na-save mo na ang code sa text editor, pinapayagan ka ng terminal ng Ubuntu na i-execute ang source code sa loob ng file sa pamamagitan ng g++ compiler.
$ g++ -o mem mem.c$ ./mem
Sa pagpapatupad, makikita mo ang mga halaga na itinalaga sa memorya.
Halimbawa 2
Ang halimbawang ito ay may kinalaman sa pakikipag-ugnayan ng user. Kukuha kami ng variable ng numero na maglalaman ng value mula sa user. Iimbak ng program na ito ang resulta sa GPA ng mga mag-aaral. Ang lahat ng mga resulta ay ise-save sa oras ng pagtakbo.
Kapag ipinasok ng user ang bilang ng mga mag-aaral, ang memorya ay inilalaan laban sa bawat numero. Ang isang float type pointer ay sinisimulan dito na gagamitin sa memory allocation ng mga resulta.
Kinukuha namin ang pointer sa float dahil ang GPA ay nasa decimal notation. Kumuha kami ng array ng pointer type para sa GPA dahil maaari itong magresulta sa isang bilang ng mga mag-aaral.
Ang pointer array na ito na may 'bagong' keyword ay magbubuklod sa pagpapatupad sa memorya. Ang GPA ay ilalagay para sa bawat mag-aaral. Dahil hindi kami pamilyar sa bilang ng mga mag-aaral na gustong idagdag ng user, gumamit kami ng for loop para ipasok ang GPA hanggang sa inilagay na numero. Sa bawat pag-uulit ng loop, ang user ay inquire na ipasok ang resulta na nagpapakilala sa mag-aaral. Kapag na-save na ang resulta, muli kaming gagamit ng loop upang ipakita ang lahat ng GPA ng mga mag-aaral. Sa huli, ang array ng uri ng pointer ay tatanggalin, dahil natupad ang layunin ng dynamic na imbakan.
Tanggalin [ ] ptr ;Ngayon ay isasagawa namin ang nabanggit na code. Hihilingin muna sa user na ipasok ang bilang ng mga mag-aaral. Pagkatapos ay ipasok ang GPA para sa bawat mag-aaral.
Halimbawa 3
Ang halimbawang ito ay gumagamit ng bago at tanggalin ang mga operator para sa object ng klase. Naglalaman ang klase na ito ng pribadong variable ng uri ng integer na nag-iimbak ng edad. Sa pampublikong bahagi ng isang klase, nilikha ang constructor na magpapasimula ng edad sa isang numerong '10'. Ang isa pang function ay ginagamit dito na magpapakita ng edad na nasimulan sa constructor.
Ngayon ay pupunta tayo sa pangunahing programa para sa dynamic na alokasyon. Ang object ng klase ay dynamic na nilikha.
Mag-aaral * ptr = bago mag-aaral ( ) ; 
Kapag nabuo ang bagay, awtomatikong maipapatupad ang tagabuo. Isang function call ang gagawin para makuha ang edad. Ito ay gagawin sa pamamagitan ng ptr.
Ptr - > getAge ( ) ;At sa dulo, ang alaala ay ilalabas.
Konklusyon
Ang dynamic na memory allocation ay inilalaan sa run time execution ng programmer sa halip na fixed storage na tinukoy ng compiler. Ang alokasyong ito ay random na batayan at maaaring alisin pagkatapos itong gamitin. Samantalang, sa karamihan ng mga kaso, bago ang pag-alis, ang proseso ng pagpapatupad ay hihinto at ang dynamic na alokasyon na ito ay nagiging sanhi ng pagtagas ng memorya. Ipinatupad namin ang hindi pangkaraniwang bagay na ito sa iba't ibang mga diskarte sa Ubuntu Linux system gamit ang C++ programming language.