>> [MUSIC nagpe-play]
Tagapagsalita: Lahat ng karapatan.
Kaya sabihin makipag-usap tungkol sa isa pang bagay na uri ng natatangi sa C,
na kung saan ay uri ng data at mga variable.
Kapag sinasabi ko na natatangi sa C, i really ang ibig sabihin lamang sa konteksto ng,
kung kayo ay isang programmer para sa isang tunay na matagal na panahon,
na sa iyo marahil ay hindi nagtrabaho sa mga uri ng data
kung ginamit mo modernong programming languages.
Modern mga wika tulad ng PHP at JavaScript,
na gagamitin din namin makita ang isang maliit sa susunod sa mga kurso,
hindi mo talaga kailangang tukuyin ang mga uri ng data ng isang variable
kapag gumamit ka ng mga ito.
>> Ipinapahayag mo lang ito at simulan ang paggamit nito.
Kung ito ay isang integer, ito kung ito ay isang integer.
Kung ito ay isang karakter, ito ay alam ito ay isang character.
Kung ito ay isang salita, alam ito ito ay isang string, tinatawag na.
>> Ngunit sa C, kung saan ay isang mas lumang wika, kailangan namin
upang tukuyin ang mga data uri ng bawat variable
na gumawa kami sa unang pagkakataon na ginagamit namin na variable.
Kaya C ay may ilang mga built-in na mga uri ng data.
At sabihin makakuha ng pamilyar sa ilan sa mga iyon.
At pagkatapos ay pagkatapos gagamitin din namin na makipag-usap sa isang nang kaunti tungkol sa ilan sa mga uri ng data
na namin ang nakasulat para sa iyo, upang maaari mong gamitin ang mga ito sa CS50.
>> Ang una ay int.
Ang uri int data ay ginagamit para sa mga variable na tindahan ng mga halaga ng integer.
Kaya 1, 2, 3, negatibong 1, 2, 3, at iba pa.
Integers, na kung saan ay isang bagay na dapat panatilihin sa isip para sa mga pagsusulit,
palaging tumagal ng hanggang sa apat na bytes ng memorya, na kung saan ay 32 bits.
May walong bits sa isang byte.
>> Kaya ito ay nangangahulugan na ang mga hanay ng mga mga halaga na maaaring tindahan ng isang integer
ay nililimitahan ng kung ano ang maaaring magkasya sa loob 32 piraso na halaga ng impormasyon.
Ngayon na ito ay lumiliko out, ito ay matagal na ang nakalipas ay nagpasya
na kami maghiwalay na hanay ng 32 bits
sa negatibong integer at positibong integer,
bawat pagkuha ng kalahati ng mga hanay.
Kaya ang hanay ng mga halaga na kumakatawan namin may isang hanay integer mula sa negatibong 2
sa ika-31 ng kapangyarihan sa 2 hanggang ang ika-31 kapangyarihan minus 1,
maging sanhi ng kailangan mo rin ng isang lugar para sa 0.
>> Kaya talaga sa kalahati ng mga posibleng halaga maaari mong magkasya sa isang int ay negatibo,
at ang kalahati ay positibo.
At halos dito, ito ay tungkol sa mga negatibong 2 bilyon sa tungkol sa positibong 2 bilyong.
Magbigay o kumuha ng ilang daang milyong.
Kaya na kung ano ang maaari mong magkasya sa isang integer variable.
Ngayon kami ay mayroon din ng isang bagay tinatawag na isang unsigned integer.
Ngayon unsigned ints ay hindi isang hiwalay na uri ng variable.
Sa halip, unsigned ay kung ano ang tinatawag na isang qualifier.
Binabago nito ang data uri ng integer na bahagyang.
>> At sa kasong ito, kung ano ang unsigned means-- at maaari mo ring
gamitin unsigned iba pang mga uri ng data, integer ay hindi lamang ang isa.
Ano ito epektibo ang ginagawa ay doble ang positibong hanay ng mga halaga
na isang integer ay maaaring tumagal ng sa sa kapinsalaan ng hindi na nagpapahintulot
mong gawin sa mga negatibong halaga.
Kaya kung mayroon kang mga numero na kilala mo ay makakakuha ng mas mataas kaysa sa 2 bilyong ngunit mas mababa
sa 4 na bilyon, para example-- na kung saan ay 2 hanggang ika-32 power--
baka gusto mong gamitin isang unsigned int kung ikaw
malaman ang iyong mga halaga ay hindi kailanman magiging negatibo.
>> Magkakaroon ka paminsan-minsan ginagamit para sa unsigned variable
sa CS50, na kung saan ay kung bakit ako banggitin ito dito.
Ngunit muli, ang hanay ng mga halaga na kayo maaari kumakatawan sa isang wala pang kontratang integer
bilang sa t regular integer, mga 0 sa 2 hanggang ika-32 kapangyarihan minus 1,
o humigit-kumulang 0-4000000000.
Kaya kaepektibo mo na nadoble ang positive na hanay na maaari mong magkasya,
ngunit iyong ibinigay up ang lahat ng ang negatibong halaga.
>> Ngayon bilang isang bukod, unsigned ay hindi lamang ang qualifier
upang aming makita para sa variable na uri ng data.
May mga bagay na tinatawag din maikli at mahaba at const.
Const namin makita ang isang maliit na bit mamaya sa kurso.
Maikli at mahaba, marahil hindi kami.
>> Ngunit lamang malaman na may mga iba pang qualifiers.
Unsigned ay hindi ang isa lamang.
Ngunit ito ay ang isa lamang na hindi namin pagpunta sa makipag-usap tungkol sa ngayon.
Kaya lahat ng karapatan.
Kaya namin sakop ang integer.
Ano ang susunod?
>> Karakter.
Kaya karakter ay ginagamit para sa mga variable na tindahan ng nag-iisang character.
Pansamantalang trabaho ay maikli para sa character.
At kung minsan maaari mong marinig tao bigkasin ito bilang kotse.
>> Kaya mga character ay laging kumukuha ng isa byte ng memorya, na kung saan ay bits 8 lamang.
Kaya ito ay nangangahulugan na maaari nilang lamang magkasya mga halaga sa hanay ng mga negatibong 2
sa ikapitong kapangyarihan, o negatibong 128, sa 2 hanggang ika-7 ng kapangyarihan minus 1, o 127.
>> Salamat sa ASCII, ito ay matagal na ang nakalipas ay nagpasya isang paraan
upang i-map ang mga positibong numero mula sa 0-127 sa iba't-ibang mga character
na ang lahat ng umiiral sa aming keyboard.
Kaya bilang namin makita sa susunod sa ang kurso, at makikita mo marahil
dumating kabisaduhin ang ilan point, capital A, para example--
ang character capital A-- mga mapa sa number 65.
At ang mga dahilan para sa na dahil na kung ano ang ito ay
ay nakatakda sa pamamagitan ng standard na ASCII.
>> Lowercase A ay 97.
Ang karakter 0 para sa kapag kayo talagang i-type ang mga character, hindi
na kumakatawan sa bilang zero, ay 48.
Matututunan mo ang isang pares sa mga ito ang pumunta sa iyo.
At makikita mo tiyak na dumating sa kailangan mga ito nang kaunti sa ibang pagkakataon sa CS50.
>> Ang susunod na malaking uri ng data ay lumulutang point numero.
Kaya lumulutang point numero ay na kilala rin bilang tunay na numero.
Ang mga ito ay karaniwang numero na magkaroon ng isang decimal point sa kanila.
Lumulutang halaga ng point tulad ng integer ding
nilalaman sa loob ng 4 bytes ng memorya.
Ngayon ay walang tsart dito.
Walang numero ng linya, dahil naglalarawan ng mga saklaw ng isang float
ay hindi eksakto malinaw o intuitive.
>> Sapat nang sabihin sa iyo may 32 bits upang gumana sa.
At kung mayroon kang isang bilang tulad ng pay, na may
isang integer part 3, at isang lumulutang point bahagi, o decimal part 0.14159,
at iba pa, kailangan mo upang maging maaaring kumatawan sa lahat ng it--
ng integer na bahagi at ang decimal bahagi.
>> Kaya kung ano ang sa tingin mo na maaaring ibig sabihin nito?
Ang isang bagay na kung decimal makakakuha ng part na at na,
kung mayroon akong isang napakalaking integer bahagi, huwag akong
maaaring maging tumpak sa decimal bahagi.
At iyon talaga ang limitasyon ng isang float.
>> Sa kamay ay may isang problema precision.
Kami lamang magkaroon ng 32 bits upang magtrabaho kasama, kaya kami ay maaari lamang
kaya tiyak sa aming mga decimal na bahagi.
Hindi namin kinakailangang magkaroon ng isang decimal part tumpak na 100 o 200 na numero,
dahil kami ay may lamang 32 bits upang gumana sa.
Kaya na ang isang limitasyon ng isang float.
>> Ngayon kabutihang-palad may ibang uri ng data na tinatawag na
double, na medyo trato sa problemang ito.
Doubles, tulad ng kamay, ay ginagamit din upang tindahan ng tunay na mga numero, o mga lumulutang na tuldok
halaga.
Ang pagkakaiba ay na doubles ay double precision.
Maaari silang magkasya 64 bits ng data, o walong bytes.
Ano ang ibig sabihin nito?
Well, ito ay nangangahulugan na maaari naming maging ng maraming higit pa tumpak na gamit ang decimal point.
Sa halip ng pagkakaroon pi sa pitong lugar siguro, na may isang float,
maaari naming baka mayroon ito sa 30 lugar.
Kung na mahalaga, maaari mong ang paggamit ng isang double sa halip ng isang float.
Talaga, kung ikaw ay nagtatrabaho sa anumang bagay na kung saan ang
ang pagkakaroon ng isang tunay na matagal na decimal na lugar at ng maraming katumpakan ay mahalaga,
malamang na gusto mong gumamit ng isang double overfloat.
Ngayon para sa karamihan ng iyong trabaho sa CS50, isang float ay dapat magkasiya.
Ngunit alam na doubles umiiral bilang isang paraan upang medyo harapin ang katumpakan
problema sa pamamagitan ng pagbibigay sa iyo ng dagdag na 32 bits upang gumana sa para sa iyong numero.
>> Ngayon ito ay hindi isang uri ng data.
Ito ay isang uri.
At ito ay tinatawag na walang bisa.
At ako ng pakikipag-usap tungkol sa mga ito dito dahil hindi namin marahil
makikita ito ng ilang beses na sa CS50.
At maaaring ikaw ay nagtataka kung ano ang lahat ay tungkol.
>> Kaya walang bisa ay isang uri.
Ito ay hindi umiiral.
Ngunit ito ay hindi isang uri ng data.
>> Hindi kami makalikha ng isang variable ng uri walang bisa at magtalaga ng isang halaga sa mga ito.
Ngunit function, halimbawa, ay maaaring magkaroon ng isang uri void return.
Talaga, kung makita mo ang isang function na may isang uri void return,
ito ay nangangahulugan na ito ay hindi nagbabalik ng halaga.
Maaari mong isipin ng isang karaniwang function na iyong ginamit namin sa ngayon
sa CS50 na hindi nagbabalik ng halaga?
>> Printf ay isa.
Printf ay hindi tunay bumalik anumang bagay sa iyo.
Ito ay kopya ng isang bagay upang ang screen, at ito ay isa lamang
isang epekto ng kung ano ang ginagawa printf.
Ngunit ito ay hindi magbibigay sa iyo ang halaga ng isang back.
Hindi mo makuha ang mga resulta at store ito sa ilang mga variable na gamitin ito sa ibang pagkakataon.
Ito ay kopya ng isang bagay na screen at tapos ka na.
>> Kaya sinabi namin na printf ay isang walang bisa function.
Ito ay bumalik sa wala.
>> Ang perimeter listahan ng isang ay maaari ding maging void function.
At iyong nakita rin na ang lubos ng kaunti sa CS50 masyadong.
Int pangunahing walang bisa.
Ba na singsing ng isang kampanilya?
Talaga kung ano ang ibig sabihin ay na pangunahing hindi gumawa ng anumang mga parameter ay.
Walang argument na makakuha ng lumipas sa main.
Ngayon sa susunod kami makita na mayroong isang paraan upang pumasa argumento sa main,
ngunit sa ngayon kung ano na namin nakita ay int pangunahing walang bisa.
Main lamang ay hindi gumawa ng anumang argumento.
At kaya kami tukuyin na sa pamamagitan ng pagsasabi na walang bisa.
Lang kami sa pagiging napaka malinaw tungkol sa ang katunayan
na ito ay hindi gumawa ng anumang argumento.
>> Kaya sa ngayon, sapat nang sabihin na void talaga
dapat lamang maglingkod bilang isang placeholder para sa iyo bilang pag-iisip tungkol sa bilang wala.
Ito ay hindi talagang gumagawa ng anumang bagay.
Walang bumalik halaga dito.
Walang mga parameter dito.
Ito ay walang bisa.
Ito ay isang maliit na mas kumplikadong kaysa sa.
Ngunit ito ay dapat magkasiya para sa ang mas magandang bahagi ng kurso.
At sana ngayon ay mayroon ka ng isang maliit na bit higit pa sa isang konsepto ng kung ano void ay.
>> Kaya ang mga ay ang limang uri bibigyan ka magkasalubong na ay built-in sa C.
Ngunit sa CS50 din namin na magkaroon ng isang library.
CS50.h, na maaari mong isama.
At kung saan ay nagbibigay sa iyo may dalawang karagdagang mga uri
na ikaw ay malamang na ma upang gamitin sa iyong mga takdang-aralin,
o nagtatrabaho lamang sa pangkalahatan ang programming.
>> Ang unang mga ito ay bool.
Kaya ang Boolean uri ng data, bool, ay ginagamit para sa mga variable
na tindahan ng isang Boolean halaga.
Kung kailanman na iyong narinig bago ang term na ito, ikaw
maaaring malaman na ang isang Boolean halaga na kaya ng lamang
may hawak na dalawang magkaibang mga natatanging halaga.
Tama at mali.
Ngayon na ito ay tila medyo pundamental na, i-right?
Ito ay uri ng isang sorpresa na ito ay hindi umiiral sa C bilang ito ay built-in.
At sa maraming modernong mga wika, siyempre, Booleans
ay isang karaniwang uri ng default data.
Ngunit sa C, ang mga ito ay talagang hindi.
Ngunit ginawa namin ito para sa iyo.
Kaya kung sakaling kailanganin mong lumikha ng isang variable na ang uri ay bool,
siguraduhin na # include CS50.h lamang sa simula ng iyong programa,
at makikita mo na ang lumikha variable ng uri bool.
>> Kung nakalimutan mong # include CS50.h, at mo simulang gamitin ang mga variable Boolean-uri,
maaari ninyong matagpuan ang ilang mga problema kapag naka-ipon ng iyong programa.
Kaya lang ay sa pagbabantay para sa.
At siguro ay maaari mo lamang ayusin ang mga problema sa pamamagitan ng pound kabilang CS50.h.
>> Ang iba pang mga pangunahing uri ng data na aming magbigay para sa iyo sa CS50 library
ay string.
Kaya kung ano ang isang string?
String ay talagang lamang ang mga salita.
Ang mga ito ay mga koleksyon ng mga character.
Ang mga ito ay mga salita.
Ang mga ito ay mga pangungusap.
Ang mga ito ay mga talata.
Maaaring buong libro, kahit.
>> Very short na masyadong mahaba serye ng mga character.
Kung kailangan mong gumamit ng mga string, halimbawa, sa mga tindahan ng isang salita,
siguraduhin na isama ang CS50.h lamang sa simula ng inyong programa
upang maaari mong gamitin ang mga uri ng string.
At pagkatapos ay maaari kang lumikha ng mga variable type na data ay string.
Ngayon sa susunod sa mga kurso, gagamitin din namin makita na iyan ay
hindi ang buong kuwento, alinman.
Susubukan naming nakakaharap bagay tinatawag na kaayusan,
na magpapahintulot sa inyo na grupo kung ano ang maaaring isang integer at ang isang string sa isang yunit.
At maaari naming gamitin para sa sa ilang layunin, na maaaring
dumating sa madaling gamitin sa susunod sa kurso.
>> At kami na ring malaman tungkol sa natukoy na mga uri,
na nagbibigay-daan sa iyo upang lumikha ang iyong sariling uri ng data.
Hindi natin kailangan mag-alala tungkol na para sa ngayon.
Ngunit lamang malaman na iyon ang isang bagay sa abot-tanaw,
na mayroong isang pulutong mas na ito buong type bagay kaysa ako na nagsasabi sa iyo lamang
ngayon.
Kaya ngayon na aming natutunan ng kaunti tungkol sa mga pangunahing data
mga uri at ang mga uri CS50 data, sabihin makipag-usap tungkol sa kung paano gumagana sa mga variable
at likhain ang mga ito gamit ang mga uri ng data sa aming mga programa.
Kung nais mong lumikha ng isang variable, ang lahat ng kailangan mong gawin ay ang dalawang bagay.
>> Una, kailangan mo upang bigyan ito ng isang uri.
Ang ikalawang bagay na kailangan mo gawin ay bigyan ito ng isang pangalan.
Sa sandaling nagawa mo na at slapped isang semicolon sa dulo ng linya,
ka na ng isang variable.
>> Kaya narito ang dalawang halimbawa.
Number Int; char sulat ;.
Ano ang ginawa ko dito?
Lumikha ako ng dalawang variable.
>> Ang una, ang mga variable na ni pangalan ko ay number.
At bilang ay may-hawak na integer nagta-type na mga halaga, dahil ang uri nito ay int.
Letter ay isa pang variable na maaaring magkaroon ng mga letra
dahil sa kanyang uri ng data ay char.
>> Medyo prangka, di ba?
Kung nakita mo ang iyong sarili sa isang sitwasyon na kung saan ang
kailangan mong lumikha ng maramihang variable ng parehong uri,
kailangan mo lamang na tukuyin ang ang uri ng pangalan ng isang beses.
Pagkatapos lamang ng listahan ng maraming mga variable ng uri na kailangan mo.
>> Kaya maaari ko halimbawa, dito sa ikatlong linya ng code,
sabihin taas int ;, bagong linya.
Int width ;.
At iyon ay masyadong trabaho.
Gusto ko pa rin makakuha ng tinatawag na dalawang variable taas at lapad, ang bawat isa ay
ay isang integer.
Ngunit ako pinapayagan na, mga bagay na C syntax, pag-isahin ang mga ito sa isang solong linya.
Int taas, lapad; Ito ay ang parehong bagay.
Lumikha ako ng dalawang variable, isa na tinatawag na taas isa na tinatawag na lapad, na parehong
ay kaya ng mga humahawak integer value type.
>> Katulad dito, maaari kong lumikha ng tatlong lumulutang na halaga ng point sa isang beses.
Maaari ko marahil lumikha ng isang variable tinatawag na square root ng 2--
na siguro ay tuluyang matagal ang lumulutang point--
na representasyon ng mga parisukat ugat ng 2-- square root of 3, at pi.
Maaari ba akong magkaroon ng tapos na ito sa tatlong magkahiwalay na mga linya.
Magpalutang, square root 2; Magpalutang ng square root 3; lumutang pi; at na masyadong trabaho.
>> Subalit muli, maaari ko lamang pag-isahin na ito sa isang solong linya ng code.
Gagawa ng mga bagay ng isang maliit na piraso mas maikli, hindi bilang clunky.
>> Ngayon sa pangkalahatan, ito ay magandang disenyo upang lamang ipinapahayag ng isang variable kapag kailangan mo ito.
At kami ay makipag-usap sa isang maliit na kaunti pa tungkol sa na
sa susunod sa mga kurso kapag usapan namin ang saklaw.
Kaya hindi naman kailangan na lumikha ng lahat ng iyong mga variable
sa simula ng programa, na ang ilang mga tao ay maaaring magkaroon ng tapos na sa nakaraan,
o ay tiyak na isang napaka-pangkaraniwan coding pagsasanay sa maraming mga taon na nakalipas
kapag nagtatrabaho sa mga C. maaari lamang mo nais na lumikha ng isang karapatan variable kapag
kailangan mo ito.
Lahat tama.
Kaya lumikha kami ng mga variable.
Paano ko gagamitin ang mga ito?
Pagkatapos naming ipahayag ang isang variable, hindi namin kailangan
upang tukuyin ang mga uri ng data ng variable na anymore.
Sa katunayan, kung gagawin mo ito, maaari mong end up sa ilang mga kakatwang mga kahihinatnan
na makikita namin uri ng pagtakpan para sa ngayon.
Ngunit magkasiya ito upang sabihin, kakaiba mga bagay ay pagpunta
upang simulan ang nangyayari kung hindi mo sinasadyang muling magpahayag ng variable na may parehong pangalan
paulit-ulit.
>> Kaya dito mayroon akong apat na linya ng code.
At ako ay may isang pares ng mga Tingnan ang mga komento doon lamang na nagpapahiwatig
ano ang nangyayari sa bawat linya para lamang makatulong sa
ikaw ay makakuha ng nakatayo sa kung ano ang nangyayari sa.
Kaya int number ;.
Nakita mo na dati.
Iyan ay isang variable na deklarasyon.
>> Ngayon ko na nilikha ng isang variable tinatawag na numero na
may-hawak na mga halaga ng integer-type.
Ipinahayag ko na ito.
>> Ang susunod na linya ako magtatalaga isang halaga sa numero.
Number katumbas 17.
Ano ang nangyayari doon?
Ako ng paglalagay ng bilang 17 sa loob ng variable na iyon.
>> Kaya kung sakaling pagkatapos i-print out ko kung ano ang ang mga nilalaman ng numero ay sa susunod,
ito ay sabihin sa akin ito ay 17.
Kaya hindi ko na ipinahayag ng isang variable, at pagkatapos ay itinalaga ko na ito.
>> Maaari naming ulitin ang proseso muli gamit char sulat ;.
Iyan ay isang deklarasyon.
Letter katumbas capital H. Iyan ay isang assignment.
Medyo prangka, masyadong.
>> Ngayon ang prosesong ito maaaring mukhang uri ng ulok.
Bakit namin ginagawa ito sa dalawang linya ng code?
Mayroon bang mas mahusay na paraan upang gawin ito?
Sa katunayan, mayroong.
Minsan maaari mong makita ang ito na tinatawag na Pinasimulan.
Ito ay kapag ipinapahayag mo ang isang variable at magtalaga ng isang halaga sa parehong oras.
Ito ay talagang isang pretty pangkaraniwang bagay na gawin.
Kapag lumikha ka ng isang variable, ikaw ay karaniwang Gusto ito upang magkaroon ng ilang mga pangunahing halaga.
Kahit na ito ay 0 o isang bagay.
Ikaw lamang mong bigyan ito ng isang halaga.
>> Maaari mong magpasimula ng isang variable.
Int numero ay katumbas ng 17 ay katulad ng ang unang dalawang linya ng code up sa itaas.
Pansamantalang trabaho titik ay katumbas ng h ay ang parehong bilang ng mga ikatlo at ikaapat na linya ng code sa itaas.
Ang pinaka-mahalagang takeaway dito kapag kami ay deklarasyon at pagtatalaga
variable ay matapos naming Na ipinahayag ito, ang paunawa
Hindi ko na muli gamit ang mga uri ng data.
Hindi ko na sinasabi number int katumbas 17 sa ang pangalawang linya ng code, halimbawa.
Lamang ako sinasabi number katumbas 17.
>> Muli, muling deklarasyon ng variable pagkatapos nakalikha ka na ipinahayag maaari itong humantong
sa ilang mga kakatwang mga kinahinatnan.
Kaya mag-ingat ng mga na lamang.
>> Ako Doug Lloyd.
At ito ay CS50.