- Ang memorya ng stack ay lokal para sa bawat pamamaraan, at kapag bumalik ang pamamaraan, awtomatikong nililimas ito ng stack.
- Ang pandaigdigang lugar ng memorya ay naglalaan ng memorya para sa lahat ng mga variable sa buong mundo. Ang lugar ng memorya na ito ay nilikha sa simula ng programa, at sa huli, awtomatiko nitong nililimas ang lugar ng memorya.
- Ang tambak na memorya ay palaging kalaban na tinutupad ang lahat ng mga kinakailangang kinakailangan ng programa / aplikasyon. Sa tuwing gagamitin namin ang pagpapaandar ng malloc, manghihiram ito ng ilang memorya mula sa bunton at bibigyan kami ng pointer dito.
Syntax:
Ang syntax ng malloc ay (walang bisa *) malloc (laki_t laki). Kaya't sinabi ng syntax na ang malloc ay nangangailangan ng isang sukat, ibabalik nito ang pointer karaniwang isang walang bisa na pointer at laki ng t ay tinukoy bilang isang unsigned integer. Ang pag-andar ng Malloc ay naglalaan lamang ng isang bloke ng memorya alinsunod sa laki na tinukoy sa tambak tulad ng nakikita mo sa syntax na ang laki ay kailangang tukuyin at, sa tagumpay, binabalik nito ang isang pointer na tumuturo sa unang byte ng inilalaan na memorya iba pa ang nagbabalik ng NUL . Kaya, ang trabaho ng malloc ay upang maglaan ng memorya sa run time.
Bakit walang bisa ang pointer:
Walang ideya si Malloc kung ano ang tinuturo nito; nangangahulugan lamang ito na hindi nito alam kung anong data ang iimbak sa lokasyon ng memorya na iyon. Naglalaan lamang ito ng memorya na hiniling ng gumagamit nang hindi alam ang uri ng data na maiimbak sa loob ng memorya. Iyon ang dahilan kung bakit nagbabalik ito ng isang walang bisa na pointer.
Naglalaan lamang ang Malloc ng memorya pagkatapos na responsibilidad ng gumagamit na i-type ang isang naaangkop na uri upang magamit ito nang maayos sa programa. Ang void pointer ay isang pointer na maaaring magturo ng anumang uri ng data malloc na nagbabalik ng void pointer dahil hindi nito alam kung aling uri ng data ang maiimbak sa loob ng memorya na iyon.
Humihiling kami dito sa malloc na maglaan ng 6 bytes ng memorya ngayon kung ang isang matagumpay na malloc ay magbabalik ng isang walang bisa na pointer. Sa kasong iyon, kailangan naming i-type ito sa isang integer type pointer dahil nais naming mag-imbak ng isang integer sa memorya na iyon. Dito naglalaan ang malloc ng 6 bytes ng memorya sa isang tambak, at ang address ng unang byte ay nakaimbak sa pointer ptr.
Halimbawa ng Programa:
Narito ang isang simpleng halimbawa ng programa upang maunawaan ang konsepto ng malloc sa isang maayos na paraan.
Dito maaari mong makita sa pagpapaandar ng printf na hinihiling ko sa gumagamit na ipasok ang bilang ng mga integer. Idineklara namin ang dalawang variable sa itaas ng i at n. Ang variable n ay ang lugar kung saan iimbak namin ang numero na ipinasok ng gumagamit. Pagkatapos nito, mayroon kaming pagpapaandar sa malloc; nais naming ang malloc na maglaan ng sukat na sukat sa laki ng n integers. Pinaparami namin ang laki kung int sa n; bibigyan kami nito ng laki ng n integers. Pagkatapos nito, ibabalik ng malloc ang isang walang bisa na pointer, at nai-type namin ito sa isang integer pointer, at itinatago namin ang address sa loob ng ptr pointer. Ang typecasting ay mahalaga dahil ito ay isang mahusay na kasanayan.
Ngayon, kung ang pointer ay naglalaman ng Null, nangangahulugan ito na ang memorya ay hindi magagamit. Kaya't lalabas lamang kami sa labas ng programa na may katayuan sa pagkabigo sa exit. Kung hindi ito ang kadahilanan, madali nating tatakbo ang para sa isang loop.
Tatakbo ang loop mula 0 hanggang n-1, at tatanungin namin ang gumagamit na isa-isang ipasok ang integer bawat oras. Sa loob ng pag-andar ng scanf, mayroong isang bagay na nakasulat na ptr + i na alam natin na naglalaman ang ptr ng address ng unang byte ng memorya. Sabihin nating ang address na iyon ay 1000 dito ay katumbas ako ng zero sa una kaya 1000 + 0 ay 1000 kaya sa loob ng address na iyon ang aming unang integer ay maiimbak pagkatapos pagkatapos kapag ako ay naging 1 kaya 1000 + 1 na kung saan ay nainterpret nang panloob bilang (1000) +1 * 4 kung ipinapalagay ko na ang laki ng integer ay 4 bytes, at ito ay katumbas ng 1004, kaya ang susunod na integer ay itatabi sa loob ng 1004 lokasyon. At magpapatuloy ito sa ganitong paraan ang mga address ay tulad ng 1000, 1004, 1008 at iba pa. Hindi kami gumagamit ng ampersand bago ang ptr + i dahil binibigyan na kami ng ptr ng address kapag nagsusulat kami ng ptr, na kung saan ay isang simpleng pointer, at naglalaman ito ng address, hindi ang halaga, kaya walang kinakailangang ilagay ang ampersand bago ito, at ang konseptong ito ay dapat na malinaw.
Dito sa loop na ito, simpleng ginagawa namin ang isang bagay na ini-print namin ang lahat ng mga integer sa screen; malinaw naman, gumagamit kami ng ptr + i, ngunit narito, sa kasong ito, dinedepensa namin ito dahil ang ptr + i ay kumakatawan sa isang address, kaya kailangan naming itong gawing masama. Kung katumbas ako ng 0, magiging 1000 ito dahil ipinapalagay namin na ang unang address ay magiging 1000, kaya dinidisferencing namin ito; makukuha namin ang unang integer pagkatapos ay katumbas ako ng 1, at ito ay magiging 1001 ngunit binibigyang kahulugan bilang 1004 kung ang laki ng integer ay 4. Muli. Dereferencing namin ito, kaya bibigyan kami ng 2ndinteger Sa ganitong paraan, gumagana ang lahat.
Kaya, ito ay karaniwang isang simpleng programa na humihiling sa mga gumagamit na ipasok ang integer, at pagkatapos ay ipinapakita lamang namin ang mga integer na iyon sa screen. Matapos maipatupad ang programa, ipapakita ito.
Una, hinihiling namin sa gumagamit na ipasok ang bilang ng mga integer, at pagkatapos ay papasok ang gumagamit sa mga integer, at ipinapakita lamang namin ang mga ito sa screen.
Konklusyon:
Walang mali sa nabanggit na programa hangga't ipinatuloy natin ito sa isang mahabang panahon dito humihiram tayo ng memorya mula sa bunton, ngunit hindi namin binabalik ang memorya pabalik upang mag-ipon nangyayari lamang ito sa kasong iyon kung saan mayroon ang programa / aplikasyon upang tumakbo para sa isang mahabang tagal tulad ng 24 oras. Tatawagan nila muli ang pagpapaandar ng malloc, at muli nangangahulugan iyon sa tuwing humihiram sila ng memorya mula sa tambak at hindi na babalik, ito ay hindi magandang programa, kaya dapat nating isulat nang libre (ang address ng memorya na dapat ilabas) bago bumalik. Kaya't tuwing gumagamit ng malloc libre ay mahalaga. Kaya, gamit ang malloc, nakatipid kami ng memorya, at ang malloc ay naglalaan ng memorya na kasing laki ng hiling mo rito.
Maligayang dynamically alokasyon ng memorya!