DOUG LLOYD: Bilang ka magsimula nagtatrabaho sa mga pag-andar,
isa pang bagay ay pagpunta sa maging talagang mahalaga na maunawaan,
na kung saan ay ang konsepto ng variable na saklaw.
Kaya saklaw ay isang katangian ng isang variable
na tumutukoy kung saan ang mga function maaaring ma-access na variable.
>> Mayroong dalawang pangunahing mga saklaw sa C, lokal na mga variable at global variable.
Ngayon, ang mga lokal na mga variable ay maaari lamang ma-access sa loob ng function
kung saan sila ay nilikha.
Hindi nila maaaring ma-access sa pamamagitan ng lahat ng iba pang function na umiiral sa iyong programa,
lamang ang mga function sa na kung saan ito ay nilikha.
Global variable, sa kabilang dako, maaaring ma-access
sa pamamagitan ng anumang mga function sa programa.
At ang mga dahilan para sa na dahil hindi sila ay ginawa sa loob ng
ng anumang partikular na function.
Ipinapahayag namin ang mga ito sa labas ng ang lahat ng mga pag-andar, kung saan
ay nangangahulugan na alam ng bawat pag-andar na kung saan ang ito ay at maaaring ma-access at paggamit ng ito.
>> Sa ngayon sa course na sa iyo pretty marami ay nagtatrabaho ng eksklusibo
sa mga lokal na mga variable.
Narito ang isang halimbawa ng isang tunay, tunay simple pangunahing pag-andar at isang napaka-simple
karagdagang function na namin ang nakasulat.
Sa kasong ito, x, na kung saan Ko na kulay berde lamang
upang i-highlight ang mga lugar o ang saklaw ng variable na iyon,
lokal sa function na triple.
pangunahing hindi maaaring tumukoy sa x sa lahat.
Hindi nito alam kung ano ito.
Walang iba pang mga function, sa katunayan, kung kami ay nagkaroon ng karagdagang function in dito,
maaaring tumukoy sa x.
>> Katulad nito, ang mga resulta kung saan hindi ko na kulay na asul, ang mga lokal na lamang sa main.
Tanging pangunahing nakakaalam kung ano ang resulta variable ay.
triple hindi maaaring gamitin ito.
>> Ngayon tulad ng nabanggit ko, mga pangkalahatang variable umiiral.
Kung ipinapahayag mo variable na sa labas ng anumang function,
ang lahat ng mga function sa programa ay maaaring sumangguni sa mga ito.
Kaya sa kasong ito na-highlight ko sa green isang pandaigdigang variable deklarasyon.
Sa kasong ito, ang mga variable pagkatao ipinahayag
ay tinatawag na global, para lamang maging lubhang malinaw tungkol sa mga ito.
Ito ay uri ng float.
At ako italaga ito ang halaga 0.5050.
>> Mapapansin mo na sa main at sa triple, ako ay ma-refer sa global.
At sa katunayan, kung pumunta ako sa pamamagitan ng programa gaya ng ipinahiwatig, main unang tawag triple,
triple multiply global sa pamamagitan ng 3, na kung saan nagtatakda ng halaga nito sa 1.5-bagay,
1.51 o isang bagay tulad na, at pagkatapos main din kopya ang halaga
ng global.
Kaya pangunahing hindi i-print out 0.5050, ito ay i-print out global beses 3, 1.51.
Kaya mo na nakuha upang maging maingat kapag ikaw ay nagtatrabaho sa mga pangkalahatang variable.
Habang ang mga ito lubos na kakayahang umangkop sa kawalan ng kakayahang ipasa ang impormasyon
sa paligid upang ang bawat Maaaring gamitin ito function,
ito rin ay maaaring magkaroon ng ilang mga mapanganib na kahihinatnan
kung ang mga pagbabago sa isang function ang halaga ng isang variable
bago mo inaasahan na ito ay nagbago.
>> Bakit ang pagkakaiba na ito mahalaga?
Bakit namin pag-aalaga kung ilang mga variable ay lokal at ang iba ay global?
Well, para sa karamihan ng bahagi, ang mga lokal na mga variable sa C ay kung ano ang tinatawag na ipinasa ng halaga
kapag gumawa kami ng isang function na tawag.
Ano ang ibig sabihin nito?
>> Well, kapag ang isang variable ay lumipas sa pamamagitan ng halaga, ang callee, na
ay isa pang paraan ng pagsasabi sa mga function na tumatanggap ng mga variable na
makakakuha ng lumipas sa bilang isang input, ito ang tunay ay hindi makatanggap ng na variable mismo.
Ito na natatanggap ng kanyang sariling kopya ng mga ito upang magtrabaho sa.
Ito ay isang tunay mahalagang pagkakaiba.
Nakita namin lamang ng isang segundo na nakalipas na may pangkalahatang variable,
kung manipulahin namin ang global variable sa isang function, ang epekto
sa na ang isang function nagdadala sa pamamagitan ng sa bawat iba pang mga function.
>> Ngunit sa mga lokal na variable, iyan ay hindi totoo.
Ang bawat function kapag ito natatanggap na mga variable ng input
tumanggap ng mga kopya ng mga variable, hindi ang mga variable sa kanilang sarili.
Kaya kung ano ang epekto ng mga iyon?
Ito ay nangangahulugan na ang mga variable sa ang tumatawag, ang function na
ay ang paggawa ng mga pag-andar ng tawag, ay hindi magbabago maliban kung i-override ito.
>> Halimbawa, sa ang code na ito foo ay hindi nagbago sa lahat.
Int foo ay katumbas ng 4, tumawag triple ng foo, sa loob ng tatlong beses,
Gusto naming asahan na foo gagawin na-multiply sa pamamagitan ng 3, at bumalik,
ngunit may tunay na walang epekto.
>> Narito bagaman, isang napaka-pino pagkakaiba.
Ito ay magkaroon ng epekto ang gusto namin.
Nakikita mo ba kung bakit?
Kami ay pinakamahalaga foo sa pangunahing oras na ito.
>> Kaya int foo ay katumbas ng 4, foo katumbas triple foo, kapag gumawa kami ng tawag na iyon,
triple makakakuha sariling kopya ng foo, may sariling kopya ng 4.
Sinasabi nito bumalik 4 na beses 3, o kahit na ano variable ay makakakuha ng lumipas na sa panahon 3.
At pagkatapos naming italaga ang return halaga ng triple sa foo muli.
Kaya ito talaga ay papatungan foo.
Ito ay ang tanging paraan upang gawin sa mga lokal na variable.
Kaya ngayon kung namin magdagdag ng isa pang linya ng code dito
sa dulo ng main sa i-print out ang halaga ng foo,
ito ay sa katunayan i-print ang 12.
>> Variable saklaw ay karaniwang hindi masyadong maraming ng isang problema
kung ang pangalan ng lahat ng iyong mga variable iba't ibang mga bagay.
Ngunit ito ay maaaring makakuha ng mga uri ng mga bastos kung ang parehong pangalan ng variable
lumilitaw sa maramihang mga pag-andar, na kung saan ang mangyayari sa isang pulutong.
Kung ikaw ba ay gagana sa sa tunay na mundo kung saan
ikaw ay nagtatrabaho sa collaborative mga programa at mga tao sa iba't ibang mga koponan
ay gumagawa ng magkasama upang isulat ang parehong programa o mga katulad na hanay ng mga programa,
ang mga ito ay madalas na muling gamitin ang mga variable pangalan, partikular na karaniwan sa buhay
tulad ng x, y, i, j, at iba pa.
>> Ngunit kapag variable ay may parehong pangalan, mga isyu sa saklaw
ay maaaring makakuha ng isang maliit na trickier upang i-parse.
Halimbawa, alam mo ba kung ano ang nais ipi-print out
sa dulo ng mga ito partikular na programa?
Kumuha nang isang minuto.
I-pause ang video at magbasa pamamagitan ng programang ito.
Maaari mong makita sa tuktok namin magkaroon ng isang function deklarasyon
para sa isang function na tinatawag na pagdagdag.
Function na tumatagal ng isang solong parameter, na isang integer na tinatawag naming x.
At ito outputs isang integer.
Iyan ay ang uri ng return sa simula.
>> Pagkatapos kami ay may pangunahing, isang pares ng mga linya ng code sa main, ang huling ng kung saan
ay isang pahayag print.
At tandaan, na ang mga tanong dito.
Ano ang tunay na magiging nakalimbag sa dulo ng function na ito?
At pagkatapos ay ang tunay na namin ang mga kahulugan ng paglakas sa ibaba.
>> Kaya maglaan ng isang minuto, na hakbang sa pamamagitan ng ang code, bakas na mga bagay.
Alam mo ba kung ano ang ipi-print sa sa katapusan ng partikular na programa?
>> Lahat tama.
Sana, na iyong kinuha ng ilang segundo upang subukan at i-parse ang isang ito.
Gawin ito nang magkasama.
>> Kaya tumawid ako out paglakas ni deklarasyon sa tuktok doon.
Ito ay uri ng isang libangan.
Ito ay hindi kanyang sariling variable.
Hindi nito ay may sarili nitong mga saklaw.
Ito ay isang function na lamang deklarasyon, kaya para sa mga layunin
ng sinusubukan mong i-parse out kung ano ang nangyayari sa programa na ito,
maaaring pati na rin maiwasan lang namin ito.
>> Ngayon kami ay may sa kasong ito, ang mga dahilan ng problemang ito ay mapanlinlang
ay dahil kami ay may lokal na mga variable sa parehong pangunahing at pagdagdag, ang bawat isa ay
ay tinatawag na x.
At syempre ang puno ng ang isyu na ito ay sinusubukan na suss out na x ay makakakuha ng nagbago
at paano ito makakuha ng nagbago.
Kaya ko na kulay na ako bawat pagkakataon ng x na ang mga lokal na pangunahing red.
At ko na may kulay ang bawat pagkakataon ng x na lokal sa pagdami asul.
>> Notice sa na ikatlong linya ng main, ay katumbas ng y paglakas
x, na paglakas ay hindi pagiging lumipas x main, o ang red x.
Pagkuha Ito ay lumipas ang isang kopya ng mga ito.
At ito ay lamang ang pagpunta upang gumana sa na kopya ng mga ito, ang mga asul na x.
Kung ikaw ay mathematically hilig, maaari ka
sa halip ay naisip ng mga ito bilang x sub m para sa pangunahing at x sub i para sa pagdagdag.
Ngunit ito ay ang parehong mga ideya.
x sub m, o ang pulang x sa nakaraang slide,
ay ang mga variable na local-- ay ang halimbawa ng x sa halip na
lokal sa main, at x sub i, o ang asul na mga variable sa mga naunang slide,
ang mga pagkakataon ng mga x na mga lokal na dagdagan.
>> Kaya, ay magawa mong malaman kung ano ang nakalimbag sa dulo ng function na ito?
Ako Doug Lloyd, at ito ay CS50.