Pagkakaiba sa pagitan ng bago at malloc ()
Nilalaman
Ang bago at malloc () kapwa ay ginagamit upang pabagu-bago ng paglalaan ng memorya. Bagaman, ang bago at malloc () ay magkakaiba sa maraming kahinaan. Ang pangunahing pagkakaiba sa pagitan ng bago at malloc () ay iyon bago ay ang operator, ginamit bilang isang konstruksyon. Sa kabilang banda, ang malloc () ay isang karaniwang pag-andar ng aklatan, na ginagamit upang maglaan ng memorya sa runtime. Ang iba pang mga pagkakaiba sa pagitan nila ay tinalakay sa ibaba sa tsart ng paghahambing:
- Tsart ng paghahambing
- Kahulugan
- Pangunahing Pagkakaiba
- Konklusyon
Tsart ng paghahambing
| Batayan para sa Paghahambing | bago | malloc () |
|---|---|---|
| Wika | Ang operator ng bagong ay isang tiyak na tampok ng C ++, Java, at C #. | Ang function malloc () ay isang tampok ng C. |
| Kalikasan | "bago" ay isang operator. | malloc () ay isang function. |
| sukat ng( ) | ang bagong doesnt ay nangangailangan ng sizeof operator na nagbibigay ng sapat na memorya para sa tiyak na uri | Kinakailangan ng malloc ang operator ng sizeof upang malaman kung ano ang laki ng memorya nito na maglaan. |
| Tagagawa | Ang operator ng bagong ay maaaring tumawag sa tagabuo ng isang bagay. | Ang malloc () ay hindi maaaring tumawag sa isang tagabuo. |
| Initialization | Ang bagong operator ay maaaring magsimula ng isang bagay habang naglalaan ng memorya dito. | Ang pagsisimula ng memorya ay hindi maaaring gawin sa malloc. |
| Sobrang karga | Ang bagong operator ay maaaring ma-overload. | Ang malloc () ay hindi maaaring ma-overload. |
| Pagkabigo | Sa pagkabigo, ang bagong operator ay nagtatapon ng isang pagbubukod. | Sa kabiguan, ang malloc () ay nagbabalik ng isang Null. |
| Deallocation | Ang paglalaan ng memorya sa pamamagitan ng bago, deallocated gamit ang "tanggalin". | Ang paglalaan ng memorya sa pamamagitan ng malloc () ay ipinagpaliban gamit ang isang libreng () function. |
| Pagpapansin | Ang bagong operator ay hindi muling ibinahagi ang memorya. | Ang memorya na inilalaan ng malloc () ay maaaring muling ibalik gamit ang realloc (). |
| Pagpatay | Ang bagong operator ay pinuputol ang oras ng pagpapatupad. | Ang malloc () ay nangangailangan ng mas maraming oras para sa pagpapatupad. |
Kahulugan ng bago
Ang namamahala bago ay isang operator ng alokasyon ng memorya na naglalaan ng memorya ng pabagu-bago. Ang bagong operator ay naglalaan ng memorya sa bunton at ibabalik ang panimulang address ng memorya na kung saan ay itinalaga sa isang variable na sanggunian. Ang bagong operator ay katulad ng malloc () sa C. Gayunpaman, ang C ++ compiler ay katugma sa malloc () ngunit, mas mahusay na gumamit ng bagong operator dahil mayroon itong ilang mga pakinabang sa malloc (). Ang syntax ng bagong operator ay ang mga sumusunod:
type variable_name = bagong uri (parameter_list);
Dito, ang "uri" ay nagpapahiwatig ng datatype ng variable na kung saan dapat na ilaan ang memorya. Ang salitang "variable_name" ay ang pangalan na ibinigay sa variable na sanggunian na nagpapanatili sa memorya. Tinutukoy ng panaklong dito ang pagtawag sa tagapagtayo. Ang parameter_list ay ang listahan ng mga halaga na ipinasa sa tagabuo upang masimulan ang bagong itinayong object.
Ang bagong operator ay naglalaan ng sapat na memorya na kinakailangan para sa isang bagay ng isang tukoy na uri. Samakatuwid, hindi ito nangangailangan ng isang sizeof () operator ni hindi nangangailangan ng pagbabago ng laki ng memorya tulad ng malloc () na gumagamit ng realloc () upang muling ibalik ang memorya. Ang bagong operator ay isang konstruksyon; tinawag nito ang tagapagtayo ng isang bagay habang idineklara na karaniwang ginagamit upang simulan ang bagay.
Alam namin na ang bagong operator ay naglalaan ng memorya sa bunton at ang laki ng magbunton ay limitado. Kaya, kung ang bunton ay wala sa memorya at ang mga bagong operator ay nagtatangka na maglaan ng memorya, hahantong ito sa kabiguan ng bagong operator. Kung ang bagong operator ay nabigo upang maglaan ng memorya, magtatapon ito ng isang pagbubukod, at kung ang iyong code ay hindi makayanan ang pagbubukod na iyon, ang programa ay nagtatapos nang abnormally.
Ang memorya na inilalaan ng operator ng bagong ay maaaring mapalaya gamit ang tinanggal na operator. Ang bagong operator ay pinutol ang oras ng pagpapatupad dahil ito ay isang operator, hindi isang function.
Kahulugan ng malloc ()
Ang malloc () ay isang function na ginagamit upang maglaan ng hiniling na halaga ng memorya sa bunton. Ibinalik ng pamamaraan ang pointer ng uri ng 'walang bisa' na higit pa, uri ng cast upang makakuha ng isang pointer sa isang memorya ng isang tinukoy na uri at ang pointer na ito sa memorya ay itinalaga sa isang variable na sanggunian. Ang function ng malloc () ay katulad sa bagong operator sa C ++ dahil ginagamit ito upang maglaan ng memorya ng pabago-bago. Ang malloc () ay isang karaniwang pag-andar ng aklatan. Ang syntax ng malloc () function ay ang mga sumusunod:
type variable_name = (type *) malloc (sizeof (type));
Dito, ang "uri" ay nagpapahiwatig ng datatype ng variable na kung saan dapat ilaan ang memorya. Ang variable_name ay ang pangalan ng variable na sanggunian kung saan ibabalik ang pointer ng malloc (). Inilarawan ng (uri *) ang uri ng paghahagis upang makakuha ng isang pointer sa memorya sa isang tiyak na uri. Ang sizeof () ay naglalarawan sa malloc (), na kung ano ang kinakailangan sa laki ng memorya.
Ang malloc () ay nangangailangan ng uri ng paghahagis dahil ang pointer na ibinalik ng malloc () ay walang bisa, kaya, upang magtalaga ng isang uri sa pointer, kinakailangan ang uri ng paghahagis. Kinakailangan ang sizeof () dahil ang function malloc () ay naglalaan ng isang raw memory samakatuwid, kinakailangan upang sabihin sa malloc () function na kung ano ang sukat ng memorya na maglaan. Kung ang inilalaang memorya ay hindi sapat, maaari itong baguhin ang laki o reallocate gamit ang realloc ().
Ang malloc () ay gumana ng paggunita sa memorya. Sa kaso, ang bunton ay wala sa memorya noon, ang malloc () function ay nagbabalik ng isang Null pointer. Samakatuwid, ang reference variable na naglalaman ng pointer na ibinalik ng malloc (), ay dapat suriin bago ito magamit, kung hindi man ay maaaring magresulta ito sa isang pag-crash ng system.
Ang memorya na inilalaan ng malloc () function ay ipinagpaliban gamit ang libre (). Tulad ng tawag sa function na humahantong sa isang overhead, ang malloc () ay nangangailangan ng mas maraming oras para sa pagpapatupad.
- Ang bagong operator ay isang konstruksyon na ipinakilala sa C ++ at ginamit sa Java, C #, atbp Sa kabilang banda malloc () ay isang karaniwang pag-andar ng aklatan na matatagpuan lamang sa C wika at suportado ng C ++.
- Ang bagong operator ay naglalaan ng sapat na memorya para sa bagay ng isang tinukoy na uri, hindi ito nangangailangan ng sizing operator. Sa kabilang banda, ang pagpapaandar ng malloc () ay nangangailangan ng sizeof () operator upang ipaalam sa pagpapaandar na kung ano ang sukat ng memorya na maglaan.
- Ang bagong operator ay maaaring tumawag sa tagabuo ng bagay habang idineklara. Sa kabilang banda, ang function ng malloc () ay hindi maaaring tawagan ang tagapagtayo.
- Maaaring ma-overload ang bagong 'operator' ngunit ang malloc () ay hindi maaaring.
- Kung nabigo ang bagong operator na maglaan ng memorya, ibinabato nito ang isang pagbubukod na dapat hawakan ng code kung saan tatapusin ang programa. Sa kabilang banda, ang pagpapaandar ng malloc () ay nagbabalik ng isang Null pointer kung hindi ito maglaan ng memorya. Kung ang pointer ay ginagamit nang hindi sinuri ito, magreresulta ito sa isang pag-crash ng system.
- Ang memorya na inilalaan gamit ang isang bagong operator ay maaaring ma-deallocate gamit ang 'tanggalin'. Sa kabilang banda, ang memorya na inilalaan gamit ang malloc () function ay maaaring mapalitan gamit ang libre ().
- Kapag inilalaan ang memorya gamit ang isang bagong operator, hindi ito maaaring baguhin ang laki. Sa kabilang banda, ang memorya na inilalaan gamit ang malloc () function ay maaaring muling ibalik (baguhin ang laki) gamit ang realloc () function.
- Ang oras ng pagpapatupad ng bago ay mas mababa kumpara sa malloc () dahil ang malloc ay isang function at bago ay isang konstruksyon.
Konklusyon:
Ang function ng malloc () ay ang lumang paraan upang pabalikin ang paglaan ng memorya. Ngayon, ang bagong operator ay ginagamit upang maglaan ng memorya sa runtime dahil mayroon itong tiyak na pakinabang sa malloc ().
