[Powered by Google Translate] Natin makipag-usap tungkol sa mga array.
Kaya bakit namin nais na gumamit ng array?
Well sabihin nating mayroon kang isang programa na kailangan upang mag-imbak ng mga 5 ID ng mag-aaral.
Maaaring mukhang makatwirang sa 5 hiwalay na variable.
Para sa mga kadahilanan na namin makita sa isang bit, sisimulan namin ang pagbibilang mula 0.
Ang mga variable na kakailanganin naming int id0, int id1, at iba pa.
Anumang logic na gusto namin upang gumanap sa isang mag-aaral ID ay kailangang kopyahin at ilagay
para sa bawat isa ng mga mag-aaral ID.
Kung gusto naming upang suriin kung saan ang mga mag-aaral mangyari sa CS50,
ipapakita muna namin ang kailangan upang suriin kung id0 kumakatawan sa mag-aaral sa kurso.
Pagkatapos gawin ang parehong para sa susunod na mag-aaral, kakailanganin naming upang kopyahin at i-paste ang code para sa id0
at palitan ang lahat ng mga mga pangyayari ng id0 may id1 at iba pa para sa id2, 3, at 4.
>> Sa lalong madaling marinig mo na kailangan namin upang kopyahin at i-paste,
dapat mong simulan ang iniisip na mayroong isang mas mahusay na solusyon.
Ngayon kung ano ang kung Napagtanto mong hindi mo kailangan ng 5 ID mag-aaral kundi 7?
Kailangan mo upang bumalik sa iyong source code at idagdag sa isang id5, isang id6,
at kopyahin at i-paste ang logic para sa pagsusuri kung ang mga ID nabibilang sa klase para sa ang 2 bagong ID na.
May ay walang pagkonekta ng lahat ng mga ID, at kaya walang paraan ng humihiling sa
programa upang gawin ito para sa mga ID 0 hanggang 6.
Na rin ngayon ay nauunawaan mo mayroon kang 100 ID ng mag-aaral.
Ito ay nagsisimula sa tila mas mababa kaysa sa perpektong kailangang hiwalay ipinapahayag ang bawat isa sa mga ID,
at kopyahin at i-paste ang anumang logic para sa mga bagong ID.
Ngunit marahil kami ay tinutukoy, at ginagawa namin ito para sa lahat ng 100 mga mag-aaral.
Ngunit ano kung hindi mo alam kung gaano karaming mga mag-aaral na may aktwal na mga?
May ilan lang n mag-aaral at ang iyong programa ay upang tanungin ang user kung ano na n.
Uh oh. Ito ay hindi gagana nang napakahusay.
Iyong programa ay gagana lamang para sa ilang mga pare-pareho ang bilang ng mga mag-aaral.
>> Paglutas ng lahat ng mga problemang ito ang kagandahan ng array.
Kaya ano ang isang array?
Sa ilang mga wika ng programming ng isang uri ng array ay maaaring gawin ng kaunti pang,
ngunit dito makikita naming tumuon sa pangunahing istraktura ng data ng array tulad ng makikita mo ang mga ito sa C.
Isang array ay isang malaking block ng memory. Iyan na ang lahat.
Kapag sinabi naming kami ay may isang array ng 10 integer, na lamang nangangahulugan na mayroon kaming ilang mga bloke
ng memorya na ay malaki sapat na upang i-hold ang 10 hiwalay na integer.
Ipagpalagay na ang isang integer 4 bytes, nangangahulugan ito na ang isang array ng 10 integer
ay isang tuloy-tuloy na bloke ng mga 40 bytes sa memorya.
Kahit na gumagamit ka ng maraming interes array, kung saan hindi namin ay pumunta sa dito,
pa ito sa isang malaking block ng memory.
Ang maraming interes pagtatanda ay lamang ng kaginhawahan.
Kung mayroon kang 3 ng 3 maraming interes array ng integer,
ang iyong programa ay talagang lamang ituturing ng ito bilang isang malaking block ng 36 bytes.
Ang kabuuang bilang ng mga integer ay 3 beses 3, at integer bawat tumatagal ng hanggang 4 bytes.
>> Natin ng isang pagtingin sa isang pangunahing halimbawa.
Maaari naming makita dito 2 iba't ibang mga paraan ng deklarasyon ng mga array.
Namin magkomento ang 1 sa kanila para sa programa upang makatipon
dahil ipinapahayag namin x nang dalawang beses.
Padadalhan ka namin ng isang pagtingin sa ilan sa mga pagkakaiba sa pagitan ng 2 uri ng pagdeklara sa isang bit.
Parehong ng mga linya ay magpahayag ng isang hanay ng mga laki N,
kung saan # namin na tukuyin N bilang 10.
Maaaring namin lamang bilang madaling ay humiling ang user para sa isang positibong integer
at ginagamit na integer bilang isang numero ng mga elemento sa aming array.
Gusto bago ang aming mga mag-aaral ID Halimbawa, ito ay uri ng tulad ng deklarasyon ng 10 ganap na nakahiwalay
haka-haka variable; x0, x1, x2, at iba pa hanggang sa xN-1.
Pagbalewala sa mga linya kung saan idedeklara namin ang array, mapansin buo ang mga square bracket
sa loob ng para sa loop.
Kapag namin magsulat ng isang bagay tulad ng x [3], na kung saan kukunin ko na lang basahin bilang x bracket 3,
maaari mong isipin nito gusto pagtatanong para sa haka-haka x3.
Pansinin kaysa sa isang hanay ng mga laki N, nangangahulugan ito na ang bilang sa loob ng mga bracket,
kung saan kami tatawag sa index, maaaring maging anumang bagay mula 0 hanggang N-1,
na kabuuang mga indeks ng N.
>> Mag-isip tungkol sa kung paano ito ay aktwal na gumagana
tandaan na ang array ay isang malaking block ng memory.
Ipagpalagay na ang isang integer 4 bytes, ang buong array x 40 byte bloke ng memorya.
Kaya x0 ay tumutukoy sa unang 4 bytes ng bloke.
X [1] ay tumutukoy sa susunod na 4 bytes at iba pa.
Nangangahulugan ito na ang simula ng x lahat sa programa na kailangan upang subaybayan ang mga.
Kung nais mong gamitin ang x [400], at pagkatapos ay ang programa ay alam na ito ay katumbas
sa 1,600 bytes lamang pagkatapos ng simula ng x.
Where'd makuha namin 1,600 bytes mula sa? Ito ay 400 beses lamang 4 bytes bawat integer.
>> Bago lumipat sa, ito ay napakahalaga upang mapagtanto na sa C
walang pagpapatupad ng index na ginagamit namin sa array.
Aming malaking bloke ay 10 integer lamang ang haba, ngunit walang ay sumigaw sa amin kung sumulat namin x [20]
o kahit na x [-5].
Index ay hindi kahit isang numero.
Maaari itong maging anumang arbitrary expression.
Sa programa gamitin namin ang mga variable na i mula sa para sa loop sa index sa array.
Ito ay isang karaniwang pattern, looping mula sa i = 0 sa haba ng array,
at pagkatapos ay i gamit bilang ang index para sa array.
Sa ganitong paraan epektibo ng loop sa buong array,
at maaari mong alinman sa italaga sa bawat lugar sa array o gamitin ito para sa ilang mga kalkulasyon.
>> Sa unang para sa loop, i nagsisimula sa 0,
at kaya ay italaga ang 0 spot sa array, ang halaga 0 beses 2.
Pagkatapos i palugit, at magtalaga namin ang unang puwesto sa array ang halaga ng 1 beses 2.
Pagkatapos i palugit muli at kaya sa hanggang hanggang sa magtalaga namin upang iposisyon ang N-1 sa array
ang halaga ng N-1 beses 2.
Kaya lumikha kami ng isang array na may unang 10 kahit numero.
Siguro Tabla sana ay bit mas mahusay na pangalan para sa mga variable kaysa x,
ngunit na ibinigay bagay ang layo.
Ang pangalawang para sa loop pagkatapos lamang ng mga Kopya ang halaga na namin ang naka-imbak sa loob ng array.
>> Natin subukang patakbuhin ang programa sa parehong mga uri ng mga pagdeklara ng array
at tingnan sa output ng programa.
Bilang malayo bilang maaari naming makita, ang programa behaves sa parehong paraan para sa parehong mga uri ng pagdeklara.
Natin ring kumuha ng isang pagtingin sa kung ano ang mangyayari kung namin baguhin ang unang loop hindi tumigil sa N
ngunit sa halip sabihin ng 10,000.
Paraan higit sa dulo ng array.
Oops. Siguro nakita mo ito bago.
Segmentation fault ay nangangahulugan Nag-crash ang iyong programa.
Magsisimula ka nakikita ito kapag hinawakan mo ang mga lugar ng memory, hindi mo dapat pagpindot.
Narito kami ay pagpindot sa 10,000 lugar higit sa simula ng x,
kung saan talaga ay isang lugar sa memorya na hindi namin dapat na nakadikit.
Kaya ang karamihan sa atin malamang na hindi sinasadyang ilagay 10,000 sa halip ng N,
ngunit kung ano kung gagawin namin ng isang bagay na mas banayad na tulad ng sinasabi write mas mababa sa o katumbas ng N
sa para sa kundisyon loop na iba sa mas mababa kaysa sa N.
Tandaan lamang na ang isang array ay may mga indeks mula 0 hanggang N-1,
na nangangahulugan na ang index N ay higit sa dulo ng array.
Ang programa ay hindi maaaring pag-crash ng sa kasong ito, ngunit pa rin ito ng isang error.
Sa katunayan, ang error na ito ay kaya karaniwang na ito ay may ito sariling pangalan,
isang off ng 1 error.
>> Iyon ay para sa mga ang mga pangunahing kaalaman.
Kaya ano ang mga pangunahing pagkakaiba sa pagitan ng 2 uri ng mga pagdeklara ng array?
Ang isang pagkakaiba ay kung saan napupunta ang malaking bloke ng memorya.
Sa unang deklarasyon, na Tatawag ako ang bracket-array uri,
bagaman ito ay hindi nangangahulugang isang maginoo pangalan,
ito pumunta sa stack.
Sapagkat sa pangalawang, na Tatawag ako ang pointer-array uri, ito ay pumunta sa magbunton.
Nangangahulugan ito na kapag ang mga function na babalik, ang bracket array ay awtomatikong deallocated,
kung saan tulad ng kailangan mong Tahasang tumawag libreng sa array pointer
kung mayroon ka ng isang memory mahayag.
Bukod pa rito, ang bracket array ay hindi tunay na isang variable.
Ito ay mahalaga. Ito ay isang simbolo.
Maaari mong isipin na ito bilang patuloy na tagatala pinili para sa iyo.
Ito ay nangangahulugan na hindi namin maaaring gawin ang isang bagay tulad ng x + + sa mga uri ng bracket,
kahit na ito ay perpektong bisa sa mga uri ng pointer.
>> Ang uri ng pointer ay isang variable.
Para sa uri ng pointer, mayroon kaming 2 hiwalay na mga bloke ng memorya.
Ang variable na x mismo ay naka-imbak sa stack at ay lamang ng isang pointer,
ngunit ang malaking bloke ng memorya ay naka-imbak sa magbunton.
Nag-iimbak Ang variable na x sa stack ang address
ng malaking bloke ng memorya sa magbunton.
Isang implikasyon ng mga ito ay kasama ang laki ng operator.
Kung hihilingin mo para sa laki ng array bracket, ito ay magbibigay sa iyo ang laki ng malaking bloke ng memorya,
isang bagay tulad ng 40 bytes,
ngunit kung hihilingin sa iyo para sa laki ng pointer uri ng array,
ito ay magbibigay sa iyo ang laki ng variable x sarili nito, na sa appliance ay malamang may 4 bytes.
Gamit ang pointer-array uri, ito ay imposible upang direktang humingi
ang laki ng malaking bloke ng memorya.
Ito ay hindi karaniwang magkano sa isang paghihigpit ng dahil napaka namin bihirang gusto ang laki
ng malaking bloke ng memorya, at karaniwang namin makalkula ang mga ito kung kailangan namin ito.
>> Panghuli, ang bracket array ay mangyayari upang bigyan kami ng isang shortcut para sa Sinisimulan ng isang array.
Natin makita kung paano namin maaaring isulat ang unang 10 kahit integer gamit ang shortcut initilization.
Gamit ang pointer array, may ay hindi isang paraan upang gawin ang isang shortcut tulad nito.
Ito ay isang panimula sa kung ano ang maaari mong gawin sa array.
Magpakita ang mga ito sa halos bawat programa na magsulat.
Sana maaari mo na ngayong makita ang isang mas mahusay na paraan ng paggawa ng mag-aaral halimbawa ng mga ID
mula sa simula ng video.
>> Ang pangalan ko ay Rob Bowden, at ito ay CS50.