>> [MUSIC nagpe-play]
>> DOUG LLOYD: OK.
Ginawa namin integer, kami ay nagtrabaho sa mga character,
kami ay nagtrabaho sa kamay, doubles, string, at bools.
Naubos na namin medyo marami ang lahat ng [hindi marinig] uri na
na ito ay magagamit sa amin ang lahat ng mga kasama.
Ngunit ngayon ay gusto naming gawin ang isang bagay na higit pa.
Paano namin gawin iyon?
Paano namin lumikha ng iba't ibang mga uri ng data?
Maaari naming gawin ito sa pamamagitan ng paggamit istruktura.
Kaya payagan istruktura sa amin upang mapag-isa variable ng iba't-ibang uri
sa isang solong, bagong uri ng variable, na kung saan kami ay maaaring magtalaga ng kanyang sariling uri ng pangalan.
Ito ay isang talagang malakas bagay na maaaring gawin,
dahil kami ay maaaring grupo ngayon elemento ng iba't ibang mga uri ng data
magkasama na magkaroon ng isang lohikal na koneksyon.
Napuntahan namin magawa ito may array uri ng, tama?
Maaari naming variable grupo ng parehong uri ng data
sama-sama sa isang malaking unit ng memory, isang array.
>> Ngunit hindi pa namin nagawa upang ihalo up ng iba't ibang mga uri ng sama-sama ng data.
Hindi namin maaaring, sinasabi, pares ng isang integer, at ang isang karakter, at isang double lahat
sa parehong bagay at tumawag na ang isang solong unit.
Subalit sa istruktura, o madalas tinutukoy bilang structs,
talaga namin.
Kaya ang isang istraktura ay uri ng tulad ng isang super variable.
Ito ay isang variable na naglalaman iba pang mga variable sa loob ng mga ito.
Kaya narito ang isang halimbawa ng isang napaka-simpleng istraktura.
Ito ay kung ano ang syntax ay tumingin nais na lumikha ng isang istraktura para sa isang kotse.
Ngayon, pumunta sa pamamagitan ng syntax dito.
Struct, na ang keyword na nagpapahiwatig
na ako ng paglikha ng isang bagong uri ng data dito.
Sa partikular, ang pangalan ng uri ng data ay magiging struct kotse, dahil kakailanganin namin makita.
Ngunit ito ay ang mga uri ng mga tip off na ang tagatala na ito
bilang isang grupo ng mga variable na ito ay pagpunta na isinasaalang-alang na bahagi ng parehong uri
sa isang minuto.
>> Mga sasakyan, lamang ang pangalan ng mga istraktura.
Muli, ang mga uri ng data dito ay pagpunta upang maging struct kotse, hindi lang kotse.
Ngunit kung mayroon kang different-- kung lumikha ka ng maramihang mga structs
sa parehong programa, kailangan mong makilala sa pagitan ng struct at struct.
Kaya struct kotse, maaari din akong magkaroon ng ang mag-aaral struct, halimbawa,
sa parehong programa.
Sa loob ng kulot tirante ay ang lahat ng mga tinatawag na mga patlang,
o miyembro ng istraktura.
Kaya kung ano ang ilan sa mga bagay-bagay na likas sa isang kotse?
Well, kadalasan ito ay isang taon, ay isang pangalan ng modelo, at isang plaka ng lisensya,
isang odometer na kadalasan ay may ilang bilang ng mga milya sa mga ito,
at marahil isang sukat ng engine.
At tulad ng makikita mo, ako ng paghahalo up integers at mga character at doubles.
Lahat ng mga ito ay pagpunta sa maging bahagi ng bagong uri ng data.
>> Sa wakas, ang huling bagay na kailangan kong gawin, huwag kalimutan ang maliit na tuldok-kuwit
sa dulo.
Pagkatapos matapos namin ng pagtukoy sa istraktura, kailangan naming maglagay ng semicolon sa dulo.
Ito ay isang napaka-pangkaraniwan syntactical pagkakamali, dahil sa isang function,
halimbawa, ay mayroon ka lamang bukas kulot suhay, malapit kulot suhay.
Hindi mo na maglagay ng isang tuldok-kuwit sa dulo ng isang kahulugan ng function.
Ito ay mukhang isang function kahulugan, ngunit ito ay hindi,
at sa gayon ang semicolon doon ay isang paalala lamang na kayo
kailangan mong ilagay ito doon, dahil kung hindi, ang tagatala ay hindi
malaman kung ano ang gagawin dito.
Ito ay isang napaka-karaniwang error sinasadyang gawin
kapag ikaw ay unang pagtukoy na kaayusan.
>> SIGE.
Kaya kami ay karaniwang tukuyin ang aming mga istraktura sa pinakatuktok ng aming mga programa
dahil marahil sila ay pagpunta upang magamit sa pamamagitan ng maramihang mga pag-andar.
Hindi namin nais na tukuyin ang isang struct sa loob ng isang function,
dahil pagkatapos ay maaari naming only-- ang saklaw ng istraktura talagang
ay umiiral lamang sa loob ng na function.
Gusto naming malamang na gusto mong tukuyin ang isang istraktura upang maaari naming gamitin ang mga ito sa iba't-ibang mga pag-andar,
o di kaya sa maramihang mga file na ay nakatali magkasama
upang lumikha ng aming solong programa.
Minsan halip din ng pagtukoy sa istraktura
sa pinakatuktok kung saan mo inilagay ang iyong pound nagsasama at ang iyong pound tumutukoy,
halimbawa, maaari mong ilagay ang mga ito sa hiwalay na tuldok h file, na iyo pagkatapos
pound isama ang iyong sarili.
>> Kaya kami ay may kaayusan, ngunit ngayon kailangan namin upang makakuha sa loob ng mga ito.
Paano kami makakuha ng loob ng isang istraktura sa access
mga sub-variable, ang mga variable na umiiral sa loob ng istraktura?
Well, mayroon kaming isang bagay na tinatawag na ang tuldok operator, na nagpapahintulot sa amin
upang ma-access ang mga patlang ng mga istraktura.
Kaya halimbawa, sabihin natin na Aking ipinahayag type sa tabi-tabi ang aking data istraktura
sa tuktok ng aking mga programa, o di kaya sa isang tuldok h file na ko na pound kasama.
Kung pagkatapos ay gusto kong lumikha ng isang bagong variable na ng uri ng data, maaari kong sabihin,
struct kotse, ang aking kotse, semicolon.
Katulad ng maaari kong sabihin int x, o string name semicolon.
>> Ang uri ng data dito ay struct kotse, ang pangalan ng variable ay ang aking kotse,
at pagkatapos ay maaari ko bang gamitin ang operator na tuldok sa ma-access ang iba't-ibang larangan ng aking kotse.
Kaya ang maaari kong sabihin ang aking kotse dot taon ay katumbas ng 2011.
Iyan ay ganap na multa.
Taon, kung isipin mo, ay tinukoy bilang isang integer field sa loob ng struct car
uri ng datos.
Kaya ang anumang mga variable ng data struct car uri, tulad ng aking sasakyan, masasabi ko ang aking kotse
dot taon ay katumbas at pagkatapos ay italaga ito ang ilang mga halaga ng integer, 2011.
Aking dot car plate katumbas CS50.
Aking card dot odometer katumbas ng 50,505 semicolon.
Lahat ng mga ito ay ganap na multa at iyon ang
kung paano namin ma-access ang mga patlang ng mga istraktura.
Istruktura, kahit na, hindi na kailangan na nilikha sa stack.
Katulad ng anumang iba pang mga variable, namin magilas na maaaring magtalaga ng mga ito.
Kung kami ay may isang programa na maaaring maging sa pagbuo ng maraming mga istraktura,
hindi namin alam kung gaano karaming kami ay pagpunta sa kailangan,
pagkatapos ay kailangan namin upang magilas magtalaga ng mga kaayusan
bilang aming programa ay tumatakbo.
At kaya kung kami ay pagpunta upang ma-access ang larangan ng isang istraktura sa konteksto,
pagpapabalik na kailangan muna naming dereference ang pointer sa istraktura,
at pagkatapos ay sa sandaling namin dereference ang pointer, pagkatapos ay maaari naming ma-access ang mga patlang.
Kung lamang ang mayroon kami ng isang pointer sa istraktura,
hindi namin lamang sabihin field pointer dot pangalan at makakuha ng kung ano ang aming hinahanap.
May mga dagdag na hakbang ng dereferencing.
Kaya sabihin natin na sa halip na ang previous--
tulad ng mga nakaraang mga halimbawa, sa halip ng deklarasyon ito
sa stack, struct kotse, ang aking kotse, semicolon, sinasabi ko struct kotse,
star, isang pointer sa isang struct sasakyan na tinatawag na ang aking sasakyan,
ay katumbas ng malloc laki ng struct kotse.
Sukat ng namin makikita malaman kung gaano karaming bytes iyong bagong uri ng data ay tumatagal ng up.
Hindi mo kailangang palaging lamang na gamitin ang laki ng, lapad, int, o pansamantalang trabaho, o anumang
sa mga built-in na mga uri ng data.
Ang tagatala ay matalino sapat upang malaman kung gaano karaming mga byte
ay kinakailangan ng iyong bagong istraktura.
Kaya malloc ko ang aking sarili sa isang yunit ng memorya malaki sapat na humawak ng isang struct kotse,
at kumuha ako ng isang pointer sa likod sa na bloke ng memorya,
at na pointer itinalaga sa aking kotse.
>> Ngayon, kung gusto kong mag-access larangan ng aking sasakyan,
Ako unang dereference aking kotse gamit ang dereference operator, star
na nasaksihan namin mula sa mga payo video, at pagkatapos matapos ang dereference ko,
pagkatapos ay maaari ko bang gamitin ang operator na tuldok sa ma-access ang iba't-ibang larangan ng aking kotse.
Lagyan ng star ang aking kotse dot taon ay katumbas ng 2011.
Iyon ay magkakaroon ng epekto gusto naming sa kasong ito,
dahil hindi namin magilas inilalaan ang aking kotse.
>> Iyon uri ng mga nakakainis na, bagaman, right?
May isang proseso na 2-step na ngayon.
Ngayon kami ay may sa dereference-- kami ay may isang star operator,
at kami ay may isang tuldok operator.
At bilang maaari mong asahan, dahil C programmers ibig mas maikling paraan
upang gawin ang mga bagay, mayroong isang mas maikling paraan upang gawin ito.
May isa pang operator na tinatawag na arrow, na kung saan gumagawa ang prosesong ito ay mas madaling.
Ang paraan ng paggana ng arrow ay muna ito dereferences
ang pointer sa kaliwa bahagi ng operator,
at pagkatapos, pagkatapos ng pagkakaroon dereferenced ang pointer sa kaliwa,
ito-access ang patlang sa kanan.
At kaya dati nagkaroon kami ng ganitong uri ng star ang aking kotse tuldok lahat ng mga bagay na ito,
tulad ng nagkaroon ng maraming nangyayari doon.
Ngunit kung ano ang sa halip na maaari naming gawin ay this-- aking taon arrow kotse ay katumbas ng 2011.
>> Muli, kung ano ang nangyayari dito?
Una, ako dereferencing aking kotse.
Aling muli, ay isang pointer dito.
Pagkatapos, pagkatapos ng pagkakaroon dereferenced aking kotse, ako
maaaring pagkatapos ma-access ang mga patlang taon, plato, at odometer
gaya ng dati ko bago ang pagkakaroon ng unang ginamit na star sa dereference aking sasakyan,
at tuldok na i-access ang field.
Kaya maaari kang magkaroon kaayusan, ikaw ay ay maaaring magkaroon ng mga payo sa kaayusan,
at ikaw ay may mga paraan upang ma-access larangan ng mga istruktura,
kung ikaw ay may mga payo upang ang mga ito o ang mga variable sa kanilang sarili.
Dot o arrow, depende sa kung paano ang mga variable ay ipinahayag.
Ako Doug Lloyd, ito ay CS50.