>> [MUSIC nagpe-play]
DOUG LLOYD: Lahat ng karapatan.
Paggawa gamit ang single variable ay medyo masaya.
Ngunit ano kung nais namin na magtrabaho na may maraming mga variable,
ngunit hindi namin nais na magkaroon ng isang grupo ng mga iba't ibang mga pangalan na lumilipad sa paligid ng aming mga code?
Sa kasong ito, array ay pagpunta sa dumating sa talagang magaling.
Ang mga array ay isang talagang pangunahing data structure para sa anumang wika programming
na gagamitin mo.
At ang mga ito ay tunay, tunay na kapaki-pakinabang, lalo na, dahil kakailanganin namin makita, sa CS 50.
>> Ginagamit namin ang mga array na humawak mga halaga ng parehong uri ng data
sa magkadikit na lokasyon ng memorya.
Iyon ay upang sabihin, ito ay isang paraan na kaya namin ng grupo
ng grupo ng mga integer magkasama sa memory o isang grupo ng mga character
o sa kamay sa memory talaga malapit nang magkasama at trabaho
sa kanila nang hindi upang bigyan ang bawat isa sa kanyang sariling natatanging pangalan, na maaaring
makakuha ng pahirap pagkatapos ng ilang sandali.
>> Ngayon, isang paraan upang analogize array ay mag-isip tungkol sa iyong lokal na post
opisina para sa isang segundo.
Kaya hakbang ang layo mula sa programming at isara ang iyong mga mata
at mailarawan sa iyong isipan iyong lokal na post office.
Karaniwan, sa karamihan ng mga post tanggapan, mayroong isang malaking bangko
isang kahon ng post office sa dingding.
>> Isang array ay isang higanteng block ng magkalapit memory,
sa parehong paraan na ang isang mail bangko sa iyong post office
ay isang malaking puwang sa pader ng post office.
Ang mga array ay partitioned sa maliit, identically sized na mga bloke ng puwang,
ang bawat isa ay tinatawag na isang elemento ng, sa parehong paraan na ang mga pader ng post
office ay partitioned sa maliit, identically sized na mga bloke ng puwang,
na tinatawag naming isang PO box.
Ang bawat elemento ng array Maaari tindahan ng isang tiyak na halaga ng data,
tulad ng bawat post office box ay may kakayahan upang i-hold ang isang tiyak na halaga ng mail.
>> Ano ang maaaring naka-imbak sa bawat elemento ng array ay mga variable ng parehong data
uri, tulad ng int o pansamantalang trabaho, lamang tulad ng sa iyong post office box,
maaari ka lamang magkasya bagay ng isang katulad na uri,
tulad ng mga titik o maliliit na pakete.
Panghuli, maaari naming ma-access ang bawat elemento ng array direkta sa pamamagitan ng numero index,
tulad ng maaari naming ma-access ang aming post office kahon sa pamamagitan ng alam ang numero ng mailbox nito.
Sana, na pagkakatulad tumutulong sa iyo na makuha ang iyong ulo
paligid ng ideya ng array sa pamamagitan ng analogizing sa ibang bagay
na ikaw ay malamang na na pamilyar sa.
>> Sa C, ang mga elemento ng isang array ay index simula sa 0, hindi mula sa 1.
At ito ay talagang mahalaga.
At sa katunayan, ito ay kung bakit namin, sa CS 50, at kung bakit computer siyentipiko madalas
bibilangin mula sa 0, ay dahil sa array C ni
pag-index, na kung saan ay laging nagsisimula sa 0.
Kaya kung ang isang array ay binubuo ng n elemento, ang unang elemento ng array na
ay matatagpuan sa index 0, at huling element ng array
ay matatagpuan sa index n minus 1.
Muli, kung may n elemento sa ating array, ang huling index ay n minus 1.
>> Kaya kung ang aming array ay may 50 na mga elemento, ang mga unang elemento ay matatagpuan sa index 0,
at ang huling elemento ay matatagpuan sa index 49.
Sa kasamaang-palad, o sa kabutihang-palad, depende sa iyong mga pananaw,
C ay tunay mahigpit dito.
Hindi ito ay pigilan ka mula sa pagpunta sa labas ng hangganan ng iyong array.
Ikaw ay maaaring ma-access ang minus 3 elemento ng iyong array
o ang ika-59 na elemento ng iyong array, kung ang iyong array ay may 50 elemento lamang.
Hindi ito ay titigil ang iyong mga programa mula sa ipon, ngunit sa tumakbo ng oras,
Maaaring nakatagpo ka ng isang kinatatakutang segmentation fault
kung sinimulan mo upang ma-access ang memory na nasa labas ng hangganan ng kung ano
hiniling mo sa iyong programa na magbibigay sa iyo.
Kaya huwag mag-ingat.
>> Ano ang ginagawa ng isang array deklarasyon hitsura?
Paano namin code sa isang array sa buhay tulad namin code anumang iba pang mga variable?
May tatlong bahagi sa isang array declaration-- isang uri, isang pangalan,
at isang laki.
Ito ay halos kapareho sa isang pagdeklara ng variable, na
ay lamang ng isang uri at isang pangalan, ang elemento size pagiging
ang mga espesyal na mga kaso para sa isang array, dahil nakakakuha kami ng isang bungkos ng mga ito
at sa parehong oras.
>> Kaya ang uri ay kung anong uri ng variable sa iyo Gusto bawat elemento ng array na.
Gusto ito sa isang array ng mga integer?
Pagkatapos, i-type ang iyong data ay dapat na int.
Gusto mo ito upang maging isang ang dami ng mga doble o sa kamay?
Uri ng data ay dapat na double o lumutang.
Ang pangalan ay kung ano ang iyong nais na tawagan ang iyong array.
Ano ang gusto mong ipangalan sa giant bank ng integer o sa kamay o karakter
o doubles, o kahit anong mayroon ka?
Ano ang gusto mo sa tawag na ito?
Medyo nagpapaliwanag sa sarili.
>> Panghuli, laki, na kung saan napupunta sa loob ng mga square bracket,
ay kung gaano karaming mga elemento ng ginagawa mo tulad ng iyong array na naglalaman ng.
Gaano karaming mga integer ang gusto mo?
Gaano karaming mga kamay ang gusto mo?
>> Kaya halimbawa, int marka ng mag-aaral 40.
Ito ay nagpapahayag ng isang array na tinatawag na Student marka, na binubuo ng 40 integer.
Medyo nagpapaliwanag sa sarili, pag-asa ko.
Narito ang isa pang halimbawa.
Double menu presyo 8.
Lumilikha ito ng isang array na tinatawag na Presyo Menu, na binubuo
ng mga kuwarto sa memory para sa walong doubles.
>> Kung sa tingin mo ng bawat elemento ng isang hanay ng mga uri ng data-uri,
kaya halimbawa, ang isang solong elemento ng isang hanay ng mga uri ng int, sa parehong paraan sa iyo
ay sa tingin ng anumang iba pang mga variable ng uri int,
ang lahat ng mga pamilyar na mga operasyon na namin tinalakay dati sa Operations
video ay magkaroon ng kahulugan.
Kaya dito, maaari naming ipahayag ang isang array ng Booleans tinatawag Truthtable,
na binubuo ng room para sa 10 Booleans.
>> At pagkatapos, tulad lamang namin ay maaaring lamang magtalaga isang halaga sa anumang iba pang mga variable ng uri
Boolean, kami ay maaaring sabihin ng isang bagay tulad Truthtable square bracket
2, na kung saan ay kung paano namin ipahiwatig, kung aling mga elemento ng katotohanan table?
Ang ikatlong elemento ng katotohanan mesa, dahil tandaan,
kami ay pagbibilang mula sa 0.
Kaya na kung paano namin ipahiwatig ang ikatlong elemento ng katotohanan table.
Truthtable 2 ay katumbas ng hindi totoo, tulad ng maaari naming declare--
o maaari naming magtalaga, sa halip, ang anumang Boolean uri ng variable na hindi totoo.
>> Maaari din naming gamitin ang mga ito sa mga kondisyon.
kung (truthtable 7 == true), na kung saan ay ang sabihin,
kung ang ika-walong element ng Truthtable ay totoo,
baka gusto naming i-print ang isang mensahe sa paggamit, printf ("TRUE! n") ;.
Na nagiging sanhi sa amin upang sabihin Truthtable 10 ay katumbas ng totoo, di ba?
Well, maaari ko, ngunit ito ay medyo mapanganib, dahil tandaan,
kami ay may isang hanay ng mga 10 Booleans.
Kaya ang pinakamataas na index na ang compiler ay nagbigay sa amin ay 9.
>> Ang program na ito ay sumulat ng libro, ngunit kung may ibang tao sa memory
umiiral na kung saan kami ay asahan Truthtable 10 upang pumunta,
kami ay maaaring magdusa ng segmentation fault. Kami maaaring makakuha ng malayo sa mga ito, ngunit sa pangkalahatan,
pretty mapanganib.
Kaya ang ginagawa ko dito ay legal C, ngunit hindi kinakailangan ang pinakamahusay na ilipat.
Ngayon, kapag ipinahayag sa iyo at magpasimula ng isang array ng sabay,
may tunay na isang pretty espesyal na syntax na kayo
ay maaaring gamitin upang punan ang mga array sa panimulang halaga nito.
Maaaring makakuha ng pahirap upang magpahayag ng isang hanay ng mga laki sa 100,
at pagkatapos ay upang sabihin, element 0 ay katumbas ng mga ito; element 1 ay katumbas ng mga ito;
element 2 ay katumbas iyon.
Ano ang punto, di ba?
>> Kung ito ay isang maliit na hanay, maaari mo maaaring gawin ang isang bagay tulad nito.
Bool truthtable 3 ay katumbas ng open kulot suhay at pagkatapos comma
paghiwalayin ang mga listahan ng mga elemento na nais mong ilagay sa array.
Pagkatapos isara kulot suhay semicolon.
Lumilikha ito ng isang hanay ng mga size tatlong tinatawag Truthtable,
may mga elemento na hindi totoo, totoo, at totoo.
At sa katunayan, ang Instantiation syntax ko rito ay
eksaktong katulad ng ginagawa ng mga indibidwal na syntax element ibaba.
Ang dalawang paraan ng coding gagawin makabuo ng eksaktong parehong array.
>> Katulad nito, maaari naming umulit sa ibabaw ng lahat ng mga elemento
ng isang array gamit ang isang loop, kung saan, sa katunayan, ay isang napaka-Matindi ang pinapayong
sa-bahay ehersisyo.
Paano mo lumikha ng isang array of 100 integer, na kung saan ang
bawat elemento ng array ay index nito?
Kaya halimbawa, kami ay may isang hanay ng mga 100 integer, at sa unang elemento,
gusto naming ilagay ang 0.
Sa pangalawang elemento, gusto naming ilagay 1.
Sa ikatlong element, gusto naming upang ilagay ang 2; at iba pa at iba pa.
Iyan ay isang tunay na mabuting sa-bahay na gawin exercise na iyon.
>> Dito, ito ay hindi hitsura tulad ng masyadong maraming ay nagbago.
Ngunit mapansin na sa pagitan ng square bracket, oras na ito,
Ang tunay ko na tinanggal na ang numero.
Kung gumagamit ka ng mga ito tunay espesyal Instantiation
syntax upang lumikha ng isang array, na talagang hindi
kailangan upang ipahiwatig ang laki ng array muna.
Ang tagatala ay matalino sapat upang malaman na ikaw ay tunay na
gusto ng isang hanay ng mga laki 3, dahil inilagay mo tatlong mga sangkap
sa kanan ng katumbas sign.
Kung nagkaroon ka maglagay ng apat, ito ay may bibigyan ka ng isang katotohanan talahanayan ng mga sukat apat;
at iba pa at iba pa.
>> Ang mga array ay hindi limitado sa isang solong dimensyon, kung saan ay medyo cool.
Maaari mong aktwal na magkaroon ng maraming side specifiers hangga't gusto mo.
Kaya halimbawa, kung nais mong lumikha ng isang board para sa laro Battleship, na kung saan,
kung sakaling ang naglaro, ay isang laro na ay nilalaro gamit ang mga peg sa 10 sa pamamagitan ng 10 grid,
maaari kang lumikha ng isang array tulad nito.
Maaari mong sabihin Bool battleship square bracket 10
closed square bracket square bracket 10 sarado square bracket.
>> At pagkatapos, maaari mong piliin na bigyang-kahulugan na ito sa iyong isip bilang isang 10
sa pamamagitan ng 10 grid ng mga cell.
Ngayon, sa katunayan, sa memorya, tunay na ginagawa ito lamang
mananatiling isang 100 element, single dimensional array.
At ito, sa katunayan, ay pumunta para sa kung ikaw may tatlong sukat o apat o limang.
Ito ay talagang lamang ay multiply lahat ng mga indices--
o lahat ng mga laki specifiers-- magkasama,
at kumuha ka ng isang one-dimensional array ng laki.
>> Ngunit sa mga tuntunin ng mga organisasyon at visualization at pang-unawa ng tao,
maaaring ito ay isang pulutong mas madali upang gumana sa isang grid
kung ikaw ay nagtatrabaho sa isang laro tulad ng Tic-tac-daliri ng paa o Battleship,
o isang bagay tulad na.
Ito ay isang mahusay abstraction, sa halip ng pagkakaroon
mag-isip tungkol sa isang Tic-tac-daliri board bilang isang linya ng siyam
parisukat o ng isang Battleship board bilang isang linya ng 100 parisukat.
Isang 10 sa pamamagitan ng 10 grid o isang tatlong sa pamamagitan ng tatlong grid ay marahil
isang pulutong mas madaling mahalata.
>> Ngayon, isang bagay na talagang mahalaga tungkol sa array.
Maaari naming ituring ang bawat indibidwal na element ng array bilang isang variable.
Nakita namin na ang mas maaga kapag kami ay nagtatalaga
ang halaga True sa tiyak Booleans o pagsubok sa kanila sa conditionals.
Ngunit hindi namin maaaring gamutin ang buong arrays kanilang mga sarili bilang mga variable.
Maaari naming hindi, halimbawa, magtalaga ng isa array sa isa pang array gamit ang assignment
operator.
Ito ay hindi legal C.
>> Kung nais namin na, para sa example-- ano Gusto namin ay ginagawa sa halimbawa na
ay upang kopyahin ang isa array na sa iba.
Kung gusto namin upang gawin iyon, kami ay tunay na kailangang gumamit ng loop upang kopyahin sa paglipas ng
bawat indibidwal na elemento nang paisa-isa.
Alam ko ito ay isang maliit na oras.
>> Kaya halimbawa, kung kami ay may mga pares mga linya ng code, ito gumagana?
Well, hindi, hindi ito gagawin, di ba?
Dahil kami ay nagsisikap upang magtalaga ng pagkain sa bar.
Iyan ay hindi pagpunta sa trabaho, dahil sa ito ay isang array,
at inilarawan namin na iyan ay hindi legal C.
>> Sa halip, kung gusto naming kopyahin ang mga nilalaman ng pagkain
sa bar, na kung saan ay kung ano ang kami ay nagsisikap upang gawin dito,
kami ay kailangan ng isang syntax tulad nito.
Kami ay may isang para sa loop na napupunta mula sa J ay katumbas sa 0 hanggang 5,
at paglakas namin J sa bawat pag-ulit ng loop at magtalaga ng mga elemento tulad ng.
Ito ay magreresulta sa bar din pagiging isa, dalawa, tatlo, apat, lima,
ngunit kami ay may sa gawin ito sa napaka mabagal element-by-element paraan,
sa halip ng sa pamamagitan lamang kopyahin ang buong array.
Sa ibang programming wika, mas modernong mga bago,
maaari mong, sa katunayan, lamang gawin na ang mga simpleng katumbas ng syntax.
Ngunit C, sa kasamaang-palad, hindi namin hindi pinapayagan na gawin iyon.
>> Ngayon, may isa pang bagay na gusto kong banggitin
tungkol sa array na ay maaaring maging isang maliit na bit mapanlinlang ang unang beses na
magtrabaho sa kanila.
Tinalakay namin sa isang video tungkol sa variable na saklaw,
na ang karamihan sa mga variable sa C, kapag tumawag ka ang mga ito sa pag-andar, ay dumaan sa pamamagitan ng halaga.
Huwag mo matandaan kung ano ang ibig sabihin nito upang pumasa ang isang bagay sa pamamagitan ng halaga?
Ito ay nangangahulugan na kami ay gumawa ng isang kopya ng variable na ini lumipas in.
Ang callee function, ang function na tumatanggap ng mga variable,
ay hindi makuha ang variable mismo.
Ito ay makakakuha ng kanyang sariling lokal na kopya ng mga ito upang magtrabaho sa.
>> Ang mga array, siyempre, gawin hindi sundin ang patakaran na ito.
Sa halip, kung ano ang tawag namin ito Dumaraan reference.
Callee Ang aktwal ay tumanggap ng array.
Ito ay hindi makatanggap ng kanyang mga sariling lokal na kopya nito.
At kung sa tingin mo tungkol sa ito, ito ang akma.
Kung array ay talagang malaki, ito tumatagal kaya magkano ng oras at pagsisikap
upang gumawa ng isang kopya ng isang hanay ng mga 100 o 1,000 o 10,000 na mga elemento,
na ito ay hindi katumbas ng halaga para sa isang gumana upang makatanggap ng isang kopya ng mga ito,
gumawa ng ilang trabaho sa mga ito, at pagkatapos ay lamang gawin sa mga kopya;
ito ay hindi kailangan na magkaroon ng ito sa pader sa paligid anymore.
>> Dahil array ay ilang malaki at nakakabahala,
ipasa namin lamang ang mga ito sa pamamagitan ng reference.
Lamang ang tiwala namin na function na na, huwag masira ng kahit ano.
Kaya ito ay tunay na makuha ang array.
Ito ay hindi makakuha ng kanyang sariling lokal na kopya nito.
>> Kaya kung ano ang ibig sabihin nito, pagkatapos ay, kapag ang callee
minamanipula elemento ng array?
Ano ang mangyayari?
Para sa ngayon, ipapakita namin pagtakpan sa ibabaw kung bakit eksaktong ito
mangyayari, bakit array ay dumaan sa pamamagitan ng reference
at lahat ng iba pa ay dumaan sa pamamagitan ng halaga.
Ngunit pangako ko sa iyo, kami ay bumalik at magbigay sa iyo ang sagot
sa mga ito sa isang mas huling video.
>> Narito ang isa pang ehersisyo para sa iyo bago namin tapusin ang mga bagay-bagay sa array.
Ang grupo ng mga code dito, na hindi partikular na mahusay na estilo,
kukunin ko na lang gumawa na caveat.
Walang mga komento sa dito, na kung saan ay medyo masamang form.
Ngunit ito ay lamang dahil gusto kong maging magagawa upang magkasya ang lahat ng bagay sa screen.
>> Sa tuktok, makikita mo na mayroon akong dalawang deklarasyon ng function para sa set array
at itakda ang int.
Set array tila kumukuha ng isang array ng apat na integer bilang input nito.
At set int tila tumatagal isang solong integer bilang input nito.
Ngunit pareho ng mga ito ay hindi magkakaroon ng isang output.
Ang output, ang pagbabalik type, sa bawat isa ay walang bisa.
Sa Main, kami ay may isang ilang linya ng code.
Ipinapahayag namin ang isang integer variable tinatawag na A at italaga ito ang halaga na 10.
Ipinapahayag namin ang isang array ng apat na integer tinatawag na B at magtalaga ng mga elemento ng 0, 1,
2, at 3, ayon sa pagkakabanggit.
Pagkatapos, kami ay may isang tawag upang i-set int at isang tawag sa set array.
Ang mga kahulugan ng set array at set int ay down sa ibaba, sa ilalim.
>> At ito, muli, hinihiling ko sa iyo ang tanong.
Ano ang makakakuha ng naka-print out dito sa dulo ng Main?
May isang printout col. Ako ay imprenta ang dalawang integer.
Ako nagpi-print out ang mga nilalaman ng A at ang mga nilalaman ng B square bracket 0.
I-pause ang video dito at kumuha nang isang minuto.
Maaari mong malaman kung ano ang mga ito function na ay i-print sa dulo?
Sana, kung ang pagpapabalik sa iyo ang pagkakaiba sa pagitan ng pagpasa sa pamamagitan ng halaga
at pagpasa sa pamamagitan ng reference, ito Ang problema ay hindi masyadong mahirap ito para sa iyo.
At ang sagot ng ginagawa mo Nakakita ay na ito.
Kung hindi ka talagang sigurado kung bakit iyon ang kaso, kumuha ng isang segundo,
bumalik, suriin kung ano ang ako ay lamang pagtalakay tungkol sa paglipas ng array
sa pamamagitan ng reference, laban sa pagpasa iba pang mga variable sa pamamagitan ng halaga,
at sana, ito ay gumawa ng isang maliit na piraso ng higit pang kahulugan.
>> Ako Doug Lloyd, at ito ay CS50.