[Powered by Google Translate] Joe MCCORMICK: Kaya ngayon kami ay upang makipag-usap tungkol sa mga variable.
Variable sa computer science ay isang paraan upang mag-imbak ng isang halaga.
Ngayon, kung ano ang at kung paano imbak ng namin na
halaga ay hindi masyadong mahalaga.
Maaari naming magkaroon ng isang halaga na isang salita, na maaari
naka-imbak bilang isang string.
O maaari naming magkaroon ng isang bagay na ay isang character,
tulad ng sulat ng.
At na naka-imbak bilang isang pansamantalang trabaho.
Namin ay maaaring magkaroon ng isang numero, tulad ng isa o 12, na magiging
naka-imbak bilang isang integer o isang int.
Pagkatapos, mayroon kaming iba't ibang mga bagay tulad ng Float, na maaaring iimbak
mga bagay tulad ng 1.01 o 111.13.
Ang mga halaga na ito ay palaging tinatawag na nababago.
Na nangangahulugan na kung naka-imbak namin ang bilang isa sa isang integer sa
ang tuktok ng isang programa sa paglaon, maaari naming baguhin ang numerong iyon sa
tatlo o pitong.
Ngayon, ang isang lokal na variable ay kung ano ang makikita mo karaniwang nakatagpo,
kapag execute ng isang function.
Kaya sabihin nating ikaw ay sa loob ng iyong pangunahing function na.
At nais mong lumikha ng isang variable na tinatawag na num.
At magpapadala kami mag-imbak ng isang integer sa loob nito.
Kaya kami maaaring sabihin na ang isang bagay tulad ng int num = 3.
Ngayon, doon pumunta ka.
Mayroon kang isang lokal na variable.
Ngayon, ang variable na ito ay maaaring baguhin sa pangunahing
function, sa pamamagitan ng sinasabi ng isang bagay tulad ng num = 6 o num = 7.
Ngunit ang iyong mga variable ay natigil sa loob ng
saklaw ng na function na.
At saklaw karaniwang nagsisimula sa ang kulot suhay sa
simula ng pangunahing at nagtatapos sa kulot suhay na
isinasara ang pangunahing function na.
At ngayon ang lokal na variable na ito ay natigil sa loob ng saklaw.
Kaya ito ay hindi na ma-access sa ibang andar,
sa labas ng pangunahing function na.
At sa sandaling ang pangunahing function na tatapusin nito pagpapatupad at
babalik, ito lokal na variable na tinatawag na num ay nawala.
Kaya sa kaibahan sa mga lokal na variable, mayroon kaming isang bagay
tinatawag na pangkalahatang variable.
Ngayon, isang pandaigdigang variable ay ipinahayag sa itaas ng
programa at maaaring ma-access kahit saan sa programa.
Kaya sabihin nating ipinahayag mo ang isang pandaigdigang variable sa tuktok ng
iyong programa, na tinatawag na pagsubok.
Ngayon, ang variable na ito ay maaaring ma-access
saanman sa programa.
Maaari mong ma-access ang mga ito sa iyong pangunahing function na o ng isang function
ibaba na.
Ngunit kung sakaling subukang upang lumikha ng isang lokal na variable sa isa sa
mga function, na may parehong pangalan sa
test, may isang kontrahan.
Dahil hindi mo alam kung saan variable na nais mong gamitin.
Gusto mo bang gamitin ang global test,
ipinahayag sa tuktok na programa?
O gusto mong gamitin ang mga lokal na variable pagsubok na
na sinusubukan upang lumikha sa loob ng function na ito?
Ngayon, ito ay isa sa mga dahilan kung bakit hindi namin nais na
lamang gumamit ng mga pangkalahatang variable malayang.
May isang bagay na tinatawag cluttering ang espasyo ng pangalan.
Kahit na hindi mo bang sabihin na, maaaring hindi mo sinasadyang lumikha ng isang
lokal na variable, sa paglaon sa programa, na may parehong
pangalan bilang ang global variable.
At ito ay hindi magpose isang malaking problema kapag ikaw ay nagtatrabaho sa
maliit na 10, 20, 30-line programa.
Sa sandaling mayroon ka ng hanggang sa libu-libong ng mga linya ng code, hindi mo
matandaan eksakto kung ano ang naka-imbak para sa global variable.
Kaya isang bagay upang isaalang-alang, kapag gumagamit ng mga lokal at global na
variable ay mag-isip tungkol sa kanilang mga saklaw.
Ngayon, ang saklaw ay tumutukoy kung saan ang mga variable na ito ay maaaring gamitin sa
sa programa.
Kaya ang isang global variable ay may kung ano ang tinatawag na pandaigdigang saklaw,
na nangangahulugan na maaari itong gamitin kahit saan sa programa.
Kapag initialize mo na variable, maaari itong gamitin sa
function na anumang, maging ito ay ang pangunahing function o
function ng function na 10 pababa, na tinatawag na foo10.
Hindi mahalaga kung saan mo ito gamitin.
Ngunit ang isang lokal na variable ay may tukoy na saklaw.
At ang saklaw ng na lokal na variable ay natutukoy sa pamamagitan ng
kung saan ito ay nasimulan.
Ngayon, ang saklaw ay karaniwang tinutukoy sa pamamagitan ng ang pagbubukas
suhay ng pag-andar na variable ay ipinahayag sa, hanggang
ang pagsasara ng suhay ng na function na.
Kaya sabihin nating ikaw ay sa pangunahing function na.
At lumikha ka ng isang variable.
Ngunit ngayon, sa loob ng pangunahing function na, tinatawag naming isa pang
gumana foo.
Sa pag-andar foo, hindi namin maaaring tumawag sa variable lang namin
nilikha sa pangunahing function na dahil hindi ito sa saklaw.
Na variable ay lamang sa saklaw sa loob ng pangunahing function na.
Kaya namin maaaring gamitin ito sa karagdagang sa, sa loob ng pangunahing function na, ngunit
hindi sa loob ng isang function na ay tinatawag na mula sa pangunahing function na.
Kaya tulad ng stack at ang magbunton, pangkalahatang variable
naka-imbak sa isang tiyak na bahagi ng memorya.
Ngayon, ang bahagi na ito ng memory ay nakasalalay sa system na
na ginagamit mo.
Ang mga pangkalahatang variable ay may dalawang magkahiwalay na mga spot na sila
naka-imbak, isa para sa mga nasimulan pangkalahatang variable, tulad ng kung
mo ay ipinahayag int test = 5, sa tuktok ng iyong programa.
At sa iba pang mga lugar para sa mga unitialized pangkalahatang variable,
kung sinabi mo lang, int pagsubok, sa tuktok ng iyong programa at
ay upang itakda ang mga variable ng pagsubok
mamaya sa programa.
Kaya ngayon ako pagpunta sa makipag-usap tungkol sa isang bagay na tinatawag # tukuyin,
kung saan ay isang paraan upang magbigay ng isang symbolic na pangalan sa isang pare-pareho.
At dito namin ang isang halimbawa ng isang C programa na kinakalkula
ang lugar ng isang lupon.
At sa tuktok ng programa naming gawin ang isang bagay na nagsasabing
# Tukuyin ang pay 3,14159.
# Tukuyin ay hindi technically lumikha ng isang global variable.
Sa halip, ito ay nagsasabi sa Preprocessor ang tagatala sa
hanapin at palitan lahat ng mga pagkakataon ng pay sa
3,14159 bago kino-compile.
Gayunpaman, ito ay magiging isang kapaki-pakinabang na diskarte para sa deklarasyon
constants, para sa paggamit sa buong programa.
Ngayon, naghahanap sa katangian ng lugar, ito ay tumatagal sa isang Float
Rad at nagbabalik lamang ang lugar ng isang lupon na may na
radius o pay r nakalapat, o pay beses Rad beses Rad.
At ito ay kung saan ang # tukuyin gumaganap ng isang pangunahing papel.
Dahil tagatala ay isa lamang palitan ang na pay
simbolo na may ang bilang 3,14159.
At kaya hindi namin na magsulat na nang paulit-ulit.
At sa susunod, kung magpasya namin upang gumamit ng higit pang mga digit ng pay, sabihin
sabihin 3.1415926, maaari naming idagdag lamang na sa tuktok ng
programa at hindi na baguhin ito,
mamaya sa programa.
Ito ay isang mahusay na paggamit ng # tukuyin.
Hindi namin nais upang mag-imbak ng pay bilang isang global na variable na ito dahil
maaaring baguhin mamaya sa programa.
At alam namin pay ay hindi nagbabago.
Isang pare-pareho.
Kaya ito bumabalot sa aming paksa ng mga pangkalahatang variable.
Kaya ngayon usapan natin ang tungkol sa pagkakaiba sa pagitan ng mga lokal at
pangkalahatang variable, kung kailan gamitin ang mga ito, depende sa kanilang
saklaw; at kung bakit hindi gamitin ang global variable sa kalooban
dahil sa cluttering ng puwang ng pangalan.
Ako Joe McCormick.
At ito ay CS50.