Pagkakaiba sa pagitan ng Array at Pointer
Nilalaman
Mayroong malapit na ugnayan sa pagitan ng array at pointer. Ang pointer ay maaaring magamit upang ma-access ang mga elemento ng array, pag-access sa buong array gamit ang pointer arithmetic, ginagawang mas mabilis ang pag-access. Mayroong isang pangunahing pagkakaiba sa pagitan ng isang pointer at isang array na, ang isang hanay ay isang koleksyon ng mga variable ng katulad na uri ng data samantalang ang pointer ay isang variable na nag-iimbak ng address ng isa pang variable. Mayroong ilang iba pang mga pagkakaiba sa pagitan ng isang array at isang pointer na tinalakay sa ibaba sa tsart ng paghahambing.
- Tsart ng paghahambing
- Kahulugan
- Pangunahing Pagkakaiba
- Konklusyon
Tsart ng paghahambing
| Batayan para sa Paghahambing | Array | Pointer |
|---|---|---|
| Deklarasyon | // Sa C ++ type ang var_name; // Sa Java. type ang var-name; var_name = bagong uri; | // Sa C ++ type * var_name; |
| Nagtatrabaho | Nagtitinda ng halaga ng variable ng homogenous na datatype. | Itago ang address ng isa pang variable ng parehong datatype bilang ang mga variable na pointer ng pointer. |
| Pagbuo | Maaaring mabuo ang isang hanay ng mga payo. | Ang isang pointer sa isang array ay maaaring mabuo. |
| Suporta sa Java | Suportahan ang konsepto ng array. | Hindi sumusuporta sa mga payo. |
| Imbakan | Ang isang normal na hanay ng mga halaga ng mga variable ng variable at pointer array ay nag-iimbak ng address ng mga variable. | Ang mga payo ay espesyal na idinisenyo upang maiimbak ang address ng mga variable. |
| Kapasidad | Ang isang array ay maaaring mag-imbak ng bilang ng mga elemento, na nabanggit sa laki ng variable variable. | Ang isang pointer variable ay maaaring mag-imbak ng address ng isang variable lamang sa isang pagkakataon. |
Kahulugan ng Array
Ang isang array ay ang koleksyon ng mga elemento ng parehong datatype, at ang lahat ng mga elementong ito ay tinukoy ng isang karaniwang pangalan, na kung saan ay ang pangalan ng isang variable variable. Ang isang partikular na elemento ng array ay maaaring ma-access sa pamamagitan ng pag-access sa tukoy na index ng array na kung saan ang elemento na iyon ay naka-imbak.Arrays ay maaaring maging isang one-dimensional na array, isang two-dimensional na array, o multidimensional na hanay. Ang isang hanay ng mga payo ay maaari ring mabuo sa isang hanay ng naglalaman ng lahat ng variable bilang variable pointer. Sa 'C ++' ang mga tatak ay statically na inilalaan, samantalang sa 'Java' ang mga pagdaragdag ay pantay na inilalaan.
// Sa C ++ type var_name; // Sa Java. type ang var-name; var_name = bagong uri;
Narito ang 'uri' ay nagsasaad ng uri ng data ng isang variable na hanay, 'var_name' ay nangangahulugang ang pangalan na ibinigay sa variable variable, 'laki' ay nagpapahiwatig ng kapasidad ng variable variable na kung gaano karaming mga elemento ng 'uri' ang maaaring maiimbak sa variable na hanay . Mayroong dalawang mga pamamaraan ng pag-access ng isang array, unang 'pointer arithmetic' at pangalawang 'array indexing', kung saan ang 'pointer arithmetic' ay mas mabilis.
// pag-access gamit ang pointer arithmetic Void display_array (int * S) {habang (* s) {cout (<< "halaga ay" << * s); * s ++; }}
Ang paggamit ng 'pointer arithmetic' ay gagana nang mas mabilis kumpara sa 'array indexing', i-access ang variable variable gamit ang index nito. Kung kailangan mong ipasa ang isang hanay ng mga payo sa isang function, maaari itong gawin sa pamamagitan ng paggamit ng parehong pamamaraan na ginagamit mo upang makapasa ng isang normal na hanay ng i.e. direktang tawagan ang function na may pangalan ng array, nang walang anumang index.
Unawain natin ito sa halimbawa
// Ipinapahayag ang hanay ng mga payo. int * p;
Dito, ipinapakita nito na ang 'p' ay isang hanay ng uri ng integer, hahawakan nito ang address ng 10 variable ng uri ng integer. Ipasa natin sa itaas ang hanay ng pointer sa isang display display ().
pagpapakita (p); // Tumawag sa display display. walang bisa display (int * d) {// Function na natatanggap ang array ng pointer. para sa (int i = 0; i <10; i ++) {cout << ("index" <
Ang pagpapaandar na ito ay magpapakita ng mga halaga, na naroroon sa mga variable, na ang mga address ay naka-imbak sa ganitong pointer array nang sunud-sunod.
Kahulugan ng Pointer
Ang pointer ay isang variable na humahawak sa memorya ng memorya ng isa pang variable. Ang datatype ng pareho, variable ng pointer at variable na ang address ay itinalaga sa isang variable ng pointer, dapat pareho. Ang variable ng pointer ay bilang ipinahayag bilang sundin.
// Pahayag sa C ++ type * pangalan;
Dito, ang 'type' ay isang datatype, 'pangalan' ang pangalan ng variable na pointer. Ang 'uri' ay tukuyin kung anong uri ng address ng variable ang maaaring maimbak sa variable ng pointer. Halimbawa, ang pointer ng integer ay mag-iimbak ng address ng variable ng integer. Mayroong dalawang pointer operator '*' at '&'. Ibinabalik ng operator 'ang halaga na matatagpuan sa address, na naka-imbak sa variable na sinusundan ng pag-sign ng' * '. Ibinalik ng operator ng '&' ang address ng variable na sinusundan ng pag-sign ng '&'.
// halimbawa int b = 10 int a = & b; // Narito ang address ng b ay naka-imbak sa variable a. // hinahayaan ang address ng b ay 2000, kaya ngayon isang = 2000. int c = * a; // Dito, ibabalik ang variable na pointer variable * ay ibabalik ang halaga na matatagpuan sa address na nakaimbak sa isang .ie. c = 10.
Mayroon lamang dalawang mga operator ng aritmetika na maaari mong gamitin sa karagdagan at pagbabawas. Kung nag-apply ka ng pagtaas sa isang variable ng pointer ng integer, dadagdagan ito ng laki ng datatype i.e. ng 2 byte, dahil ito ay isang pointer ng integer, sa pagtaas ay kakailanganin nitong ituro sa susunod na variable ng integer. Parehas ang kaso sa pag-decrement.
Ang // p ay isang halaga ng contraing ng integer pointer 2000. p ++; // ngayon p = 2002. p--; // ngayon p muli naglalaman ng 2000 bilang decremented ng dalawang bait.
- Inilalagay ng isang array ang mga variable ng mga katulad na uri ng data at ang mga uri ng data ng mga variable ay dapat tumugma sa uri ng array. Sa kabilang banda, ang variable ng pointer ay nag-iimbak ng address ng isang variable, ng isang uri na katulad ng isang uri ng uri ng variable ng pointer.
- Maaari kaming makabuo ng isang hanay ng mga payo sa array na ang mga variable ay ang mga variable na pointer. Sa kabilang banda, maaari tayong lumikha ng isang pointer na tumuturo sa isang hanay.
- Sinusuportahan ng Java ang array, ngunit hindi nito sinusuportahan ang mga payo.
- Ang isang laki ng array ay nagpapasya sa bilang ng mga variable na maiimbak nito samantalang; maaaring maiimbak ng isang variable na pointer ang address ng variable lamang
Tandaan:
Ang Java ay hindi sumusuporta o mahigpit na maiwasan ang mga payo.
Konklusyon:
Kung kailangan nating magtrabaho sa mga elemento ng data ng magkatulad na uri ng data noon, sa halip na gumana nang magkahiwalay sa mga variable, maaari kaming lumikha ng isang hanay ng mga variable na katulad ng mga uri ng data at pagkatapos ay gumana dito. Ang mga payo ay kinakailangan para sa ilang programa, nagbibigay ito ng napakalaking kapangyarihan, ngunit sa kasamaang palad, kung ang isang pointer ay naglalaman ng hindi tamang halaga, ito ang magiging pinakamahirap na bug na makahanap.
