DOUG LLOYD: Lahat ng karapatan.
Kaya ngayon ni harapin ang isang ipaalam talagang malaking topic, pag-andar.
Sa ngayon sa mga kurso, ang lahat ng mga mga programa na namin ang nagsusulat
ay nakasulat sa loob ng main.
Sila ay medyo simple programs.
Hindi mo kailangan na magkaroon ng lahat ng mga sanga at mga bagay na nangyayari.
Maaari naming magkasya lamang ang lahat ng ito sa loob ng pangunahing at ito
ay hindi makakuha ng katakut-takot na napakalaki.
Subalit ang bilang ng mga kurso ay pumunta sa at bilang kayo magsimula sa bumuo ng mga programa
malaya, marahil sila ay pagpunta upang simulan upang makakuha ng isang pulutong ng higit sa 10
o 15 na linya.
Maaari kang makakuha ng daan-daan o libu-libo o libu-libong mga linya ng code.
At ito ay talagang hindi na mabaliw sa isang pag-iisip.
Dahil dito, ito ay marahil hindi isang magandang ideya upang panatilihin ang lahat ng bagay sa loob ng main.
Ito ay maaaring makakuha ng isang maliit na mahirap na makahanap ng ano ang iyong hinahanap para sa kung gagawin mo na.
>> Sa kabutihang palad, kahit na C, at medyo marami lahat ng iba pang mga programming language na
maaaring gumana sa, ay nagbibigay-daan sa amin upang isulat function.
At lamang ako ng pagpunta sa magsagawa ng mabilis na bukod dito
banggitin na function ay isa sa lugar ng computer science.
At makikita mo ang mas maraming ng mga ito sa iba't ibang mga punto sa buong kurso
at kung magpapatuloy ka pa.
Saan mayroong isang pulutong ng mga kasing-kahulugan para sa parehong salita.
Kaya ang tawag namin sa mga pag-andar.
Ngunit maaari ring naririnig mo ang mga ito tinutukoy bilang pamamaraan,
o mga paraan, lalo na, kung na sa iyo kailanman tapos na ang anumang bagay na nakatuon sa programming
before-- at huwag mag-alala kung hindi mo pa, hindi
isang malaking deal-- ngunit sa audit oriented wika
ay madalas na tinatawag na mga pamamaraan.
Minsan ay tinatawag nilang subroutines.
Subalit sila ay talagang ang lahat ng sumangguni sa parehong mga pangunahing ideya.
>> Tingnan natin kung ano na ang ideya ay.
Ano ang isang function?
Well isang function ay talagang walang higit sa isang itim na kahon.
Ang isang itim na kahon na may isang hanay ng zero o higit pang mga input at isang solong output.
Kaya halimbawa, ito ay maaaring maging isang function.
Ito ay isang function na tinatawag na func.
At ito ay tumatagal ng tatlong input a, b, at c.
At sa loob na itim na kahon, kami ay hindi alam kung ano mismo ang mga ito,
ngunit ito ang proseso ng input sa ilang mga paraan at pagkatapos nito
ay nagbibigay ng isang solong output, sa kasong ito, z.
Ngayon upang gawin itong isang maliit mas mababa abstract, namin
maaaring sabihin na marahil kami magkaroon ng isang function na tinatawag na
magdagdag ng na tumatagal ng tatlong input a, b, at c at proseso ang output sa ilang mga paraan
sa loob ng itim na kahon sa makabuo ng isang solong output.
Kaya sa kasong ito, kung magdagdag tumatagal ng 3, 6, at 7.
Sa isang lugar sa loob ng mga magdagdag ng function, gusto namin
inaasahan sa kanila na pinagsama-sama upang makabuo ng output, na kung saan
ay 3 plus 6 plus 7 o 16.
>> Katulad nito, mayroon kang isang function na tinatawag na mult na tumatagal ng dalawang input, isang at b,
proseso ng mga ito sa ilang mga paraan tulad na ang output ng pag-andar
ay ang produkto ng dalawang input.
Ang dalawang input multiplied magkasama.
4 at 5 na dumaan sa mult, may mangyari, ang output inaasahan namin
ay 20.
Bakit tinatawag namin itong isang itim na kahon?
Well kung hindi kami ay sumusulat sa mga function na ang ating mga sarili, na kung saan
nagawa mo kaming tila sa ngayon cs50.
Nakita namin na print f, halimbawa, na ay isang katangian na hindi namin isulat
ang ating mga sarili, ngunit hindi namin gamitin ang lahat ng oras.
Kung kami ay hindi pagsulat ang mga function ng ating sarili,
hindi namin talagang kailangan upang malaman kung ito ay talagang ipinatupad sa ilalim ng hood.
>> Kaya halimbawa ang itim na kahon ko nagpakita sa iyo para lamang sa pagpaparami,
mult a, b maaaring maging defined-- at ito lamang
ilang pseudocode ay maaaring tinukoy bilang output ng isang beses b.
Na magkaroon ng kahulugan, right.
Kung kami ay may isang function na tinatawag mult na tumatagal ng dalawang input.
Nais naming asahan na ang output ng gagawin ang dalawang input multiplied magkasama,
isang beses b.
Ngunit mult maaari ring maging ipinatupad na tulad nito,
kami ay may isang counter variable na makakuha ng set sa loob ng mult sa 0.
At pagkatapos ay ulitin namin ang proseso na ito b ulit magdagdag ng isang sa counter.
Halimbawa, kung ang multiply namin 3a pamamagitan 5b, maaari naming sabihin itakda counter sa 0,
ulitin ng limang beses, magdagdag ng 3 hanggang counter.
Kaya namin magsimula sa 0 at pagkatapos ay gawin namin ito limang beses 3, 6, 9, 12, 15.
Ito ay ang parehong resulta. Kami pa ring makakuha ng 3 beses lamang ng 5
ang pagpapatupad ay naiiba.
>> Iyon ay kung ano ang ibig sabihin namin kapag sinasabi namin sa isang itim na kahon.
Ito lamang ay nangangahulugan na hindi namin talagang pakialam kung paano ito ay ipinatupad sa ilalim ng hood
hangga't ang output ay kung ano ang inaasahan namin.
Sa katunayan, iyon ang bahagi ng kontrata ng paggamit ng pag-andar, lalo na
mga function na ang iba magsulat.
Ang pag-uugali ay palaging pagpunta na tipikal, mahuhulaan
batay sa mga pangalan ng function.
At iyon ang dahilan kung bakit ito ay talagang mahalaga kapag ikaw isulat ang mga function
o kapag ang iba pang mga tao na magsulat mga function na maaari mong gamitin,
na ang mga function ay may malinaw, medyo halatang pangalan,
at ang mga mahusay na dokumentado.
Alin ang tiyak na ang kaso para sa pag-andar tulad ng naka-print na f.
>> Kaya bakit namin gamitin ang function?
Well bilang sinabi ko kanina, kung isulat namin lahat ng aming code sa loob ng pangunahing mga bagay-bagay
maaaring makakuha ng talagang mahirap at talagang kumplikado.
Daan sa amin Tungkulin ng kakayahan upang ayusin ang mga bagay-bagay at magbuwag
isang napaka-komplikadong problema sa isang pulutong mas pamahalaang sub bahagi.
Tungkulin din daan sa amin upang pasimplehin ang proseso coding.
Ito ay isang pulutong mas madali upang i-debug ang isang 10 function na linya laban sa isang 100 na linya
function o isang function 1000 linya.
Kung lamang namin kung debug maliit na piraso sa isang pagkakataon,
o magsulat ng mga maliliit na piraso sa panahon, ito ay gumagawa na karanasan sa programming
maraming mas mahusay.
Tiwala ako sa isang iyon.
>> Sa wakas, kung isulat namin function namin maaaring muling gamitin ang mga iba't-ibang bahagi.
Pag-andar maaaring recycle.
Maaari silang gamitin sa isang programa o sa iba.
Nakalikha ka na nakasulat na ang pag-andar, ang lahat ng iyo
kailangan mong gawin ay sabihin sa programa na kung saan upang mahanap na function.
Kami ay nai-recycle at paggamit ng i-print ang f para sa higit sa 40 taon.
Ngunit ito lamang ay nakasulat sa isang oras.
Medyo kapaki-pakinabang, i-right.
Lahat tama.
Kaya pag-andar ay malaki.
Alam natin na ang.
Ngayon natin simulan ang pagsusulat ng mga ito hayaan.
Magsimula sa pagkuha Ipaalam ang mga ito sa aming mga programa.
Upang magawa iyon, ang unang bagay na namin ay magpapahayag ng mga function.
Kapag ipinapahayag mo ang isang function kung ano talaga ang ginagawa mo
ay nagsasabi ng compiler, hey, kaya lang alam mo na,
Ako ay pupunta sa pagsusulat isang function sa susunod
at narito ang kung ano ito ay pagpunta sa hitsura.
Ang dahilan sa ito ay dahil compiler Maaari
gawin ang ilang mga kakatwang mga bagay-bagay kung nakita sila ng isang set ng mga simbolo
na ang mga ito ay hindi pamilyar sa.
Kaya bigyan lamang namin ang mga compiler ng ulo up, ako ng paglikha ng isang function
at ito ay pagpunta sa gawin ito.
Function pagdeklara pangkalahatan kung ikaw ay aayos ng iyong code sa isang paraan
na ang iba ay maaaring makapag- maunawaan at gumawa ng paggamit ng,
sa iyo sa pangkalahatan ay nais na ilagay ang lahat ng ng iyong mga function declarations
sa pinakatuktok ng iyong code, i-right bago mo simulan ang pagsusulat ng main kahit.
At Maginhawang, may isang napaka-karaniwang form
na sumusunod sa bawat deklarasyon function.
Lahat sila ay medyo marami ang hitsura.
May tatlong bahagi sa isang function deklarasyon, uri ng return, pangalan,
at listahan ng argumento.
>> Ngayon ang uri ng return ay kung anong uri ng variable sa function kalooban output.
Kaya halimbawa, kung sa tingin namin sa likod ng isang minuto ang nakalipas sa pag-multiply ng dalawang
numero function, kung ano ang inaasahan namin kung multiply namin ng isang integer sa pamamagitan ng isang integer
ang output ay marahil ng isang integer, right.
Multiplied dalawang integer magkasama, makakakuha ka ng isang integer.
Kaya ang uri ng return na iyon function ay int.
Pangalan ay kung ano ang gusto mong upang tawagan ang iyong function.
Ito ay marahil ang hindi bababa sa mahalagang bahagi ng function deklarasyon,
sa mga tuntunin ng pag-andar.
Ngunit ang tunay na malamang na isa sa mga pinakamahalagang bahagi
ng pag-andar na deklarasyon sa mga tuntunin ng pag-alam kung ano ang function talaga
ay.
Kung ang pangalan ng iyong function f o g o h o misteryo o isang bagay tulad na,
marahil ikaw ay pagpunta upang makakuha ng isang maliit na tripped up sinusubukan
matandaan kung ano ang mga function gawin.
Kaya mahalaga na magbigay sa iyong makabuluhang mga pangalan ng function ni.
>> Panghuli, list argument ay listahan comma separated
ng lahat ng mga input sa iyong function, bawat isa ay may isang uri at pangalan.
Kaya hindi lamang ang mayroon kayo sa tukuyin kung ano ang uri ng variable
ang function ay output, nais mo ring tukuyin ang
kung ano ang uri at mga uri ng variable sa function na ito ay tumatanggap ng input.
Kaya sabihin gawin ang isang halimbawa dito.
Hayaan lang ang dadalhin ng isang hitsura sa isang mas kongkreto.
Kaya narito ang isang halimbawa ng isang function deklarasyon ng function na
Gusto magdagdag dalawang integer magkasama.
Ang kabuuan ng dalawang integer ay pagpunta sa maging isang integer pati na rin, bilang namin lamang
napag-usapan.
At upang ang mga uri ng bumalik, dito sa berde, ay magiging int.
Iyon ay nagsasabi lamang sa amin na magdagdag ng dalawang ints ay pagpunta sa, sa pagtatapos ng araw,
output, o dumura ito pabalik out sa amin, isang integer.
Dahil kung ano ang ginagawa namin ang function na ito gusto mong bigyan ito ng isang makabuluhang pangalan.
Magdagdag ng dalawang ints tila naaangkop, isinasaalang-alang
kami ay pagkuha ng dalawang integer bilang input at sana ang mga ito sa pagdaragdag ng sama-sama.
Ito ay maaaring maging isang piraso ng isang masalimuot name at lantaran ang function na ito
ay marahil hindi kinakailangan dahil kami ay may mga karagdagan
operator, kung isipin mo mula sa aming discussion ng mga operator, dati.
Ngunit sabihin nating para lamang sa kapakanan ng argument na ang function na ito ay kapaki-pakinabang
at kaya makikita ang tawag namin sa mga ito magdagdag ng dalawang ints.
Sa wakas, ang function na ito ay tumatagal ng dalawang input.
Ang bawat isa sa kung saan ay isang integer.
Kaya mayroon kaming ito comma separated na listahan ng mga input.
Ngayon kami ay sa pangkalahatan ay nais na magbigay ng pangalan sa bawat isa sa kanila
sa gayon ay maaari nilang magamit sa loob ng function.
Ang mga pangalan ay hindi masyado mahalaga.
>> Sa kasong ito, hindi namin kinakailangang ay may anumang mga kahulugan na nakalakip sa mga ito.
Kaya maaari lamang naming tumawag sa kanila ng isang at b.
Iyan ay lubos fine.
Kung gayunman, hanapin mo ang iyong sarili sa isang sitwasyon
kung saan ang mga pangalan ng mga variable maaaring tunay na maging mahalaga,
baka gusto mong tawagan ang mga ito bagay maliban sa isang at b
upang mabigyan sila ng isang bagay na mas symbolically makahulugan.
Ngunit sa kasong ito, hindi namin talagang alam ng anumang bagay tungkol sa mga function.
Gusto lang namin na magdagdag ng dalawang integer.
Kaya kami na lang ang tawag mga integer isang at b.
Iyon ang isa sa mga halimbawa.
>> Bakit hindi ka kumuha ng isang pangalawang mag-isip tungkol sa isang ito,
kung paano mo magsulat ng isang function deklarasyon ng function na
multiplies dalawang numero ng lumulutang point?
Huwag mo matandaan kung ano ang isang lumulutang point numero ay?
Ano ang gusto ang function na ito deklarasyon hitsura?
Ko talagang pinapayo mo i-pause ang video at kumuha dito kung magkano ang oras na kailangan mo.
Mag-isip tungkol sa kung ano ito function deklarasyon ay magiging?
Ano ang gusto ay ang uri ng return?
Ano ang magiging isang makabuluhang pangalan?
Ano ang gusto ay ang input?
Kaya bakit hindi mo i-pause ang video dito at magsulat-up ng isang function deklarasyon
para sa isang function na ay multiply dalawang lumulutang point numero ng magkasama.
Inaasahan namin na kayo ay naka-pause ang video.
>> Kaya sabihin kumuha ng isang pagtingin sa isang halimbawa ng isa sa mga posibleng deklarasyon.
Magpalutang mult dalawang reals lumutang x, float y.
Ang produkto ng dalawang lumulutang point numero,
na pagpapabalik ay kung paano namin kumakatawan tunay na mga numero
o numero sa decimal na halaga sa c, ay magiging isang lumulutang point numero.
Kapag multiply mo ang isang decimal sa pamamagitan ng isang decimal,
marahil ikaw ay pagpunta upang makakuha ng isang decimal.
Gusto mong bigyan ito ng isang may-katuturang mga pangalan.
Paramihin ang dalawang reals tila fine.
Ngunit ikaw talaga ay maaaring tumawag ito mult dalawang kamay, o mult kamay.
Anumang bagay na gusto, hangga't ito nagbigay ng ilang mga aktwal na kahulugan sa kung ano ang
ito itim na kahon ay pagpunta sa gawin.
At muli, sa kasong ito, ay hindi kami mukhang may naka-attach ang anumang mga kahulugan
sa mga pangalan ng mga variable kami ay pagpasa sa,
kaya ang tawag namin sa mga ito lamang x at y.
Ngayon kung tumawag ka sa kanila ng isang bagay ibang tao, na ang ganap na fine.
Sa katunayan, kung ikaw mismo ang sa halip na ito deklarasyon
gamit doubles halip ng kamay, kung isipin mo
na doubles ay isang iba't ibang paraan upang mas tiyak
tukuyin tunay na mga numero o lumulutang na variable point.
Iyan ay lubos pinong masyadong.
Alinman sa isa sa mga magiging fine.
Sa katunayan, may ilang mga iba't ibang mga kumbinasyon
ng mga paraan upang ipahayag ang function na ito.
Ngunit ito ay dalawang pretty mabuti pa.
Ipinahayag namin ang isang function, na malaki.
Sinabi na namin ang mga compiler kung ano ito ay, kung ano ang namin ang pagpunta sa ginagawa.
Ngayon ay talagang isulat na function na ipaalam.
Bigyan ito ng isang kahulugan Hayaan, kaya na sa loob ng itim na kahon
predictable na pag-uugali ay nangyayari.
Sa katunayan, ang pag-multiply tayo ay dalawang tunay numero ng magkasama, o pagdagdag ng mga numero
sama-sama, o paggawa ng anumang mga ito ay na hiniling namin sa aming mga function na gawin.
>> Kaya sa katunayan, sabihin subukan at tukuyin ipaalam multiply ang dalawang reals saan namin lamang
usapan tungkol sa isang segundo ang nakalipas.
Ngayon ang simula ng isang kahulugan ng function
Mukhang halos eksakto ang parehong bilang isang function deklarasyon.
Mayroon akong pareho ng mga ito dito.
Sa tuktok ay ang function deklarasyon, type, pangalan, comma separated argument
list, semicolon.
Semicolon ay nagpapahiwatig na iyon ay isang function na deklarasyon.
Ang simula ng pag-andar definition hitsura halos eksakto
pareho, uri, pangalan, na pinaghiwalay ng kuwit list argument, walang tuldok-kuwit,
buksan kulot suhay.
Ang bukas kulot suhay, tulad ng namin nai-paggawa sa main,
Nangangahulugan ito na kami ngayon simula upang tukuyin
kung ano ang mangyayari sa loob ng itim na kahon na napagpasyahan naming tumawag mult dalawang reals.
Narito ang isang paraan upang ipatupad ito.
Maaari naming sabihin, maaari naming ipahayag ang isang bagong variable ng float na tinatawag na uri ng produkto
at magtalaga ng variable na sa mga oras na halaga x y.
At pagkatapos ay bumalik produkto.
Ano ang ibig sabihin return dito.
Well return ay ang paraan ipahiwatig namin na kung paano
kami ay pagpasa sa output-back out.
Kaya bumalik sa isang bagay, ay ang parehong bilang, ito ay ang output ng itim na kahon.
Kaya na kung paano mo gawin ito.
Narito ang isa pang paraan upang ipatupad ito.
Kami ay maaaring bumalik lang ulit x y.
x ay isang float.
y ay isang float.
Kaya x beses y ay isa ring float.
Hindi namin kahit na kailangan upang gumawa ng isa pang variable.
Kaya na ang isang iba't ibang mga paraan upang ipatupad ang eksaktong parehong itim na kahon.
>> Ngayon, ilipat ang isang sandali, muli i-pause ang video,
at subukan at tukuyin magdagdag ng dalawang ints, kung saan ay ang iba pang mga pag-andar na tayo
usapan tungkol sa isang sandali ang nakalipas.
Muli dito, ilagay ko na ang pag-andar pagpapahayag, at sa gayon ang tuldok-kuwit,
at isang bukas kulot suhay at isang closed kulot
suhay upang ipahiwatig kung saan kami ay punan sa mga nilalaman ng magdagdag ng dalawang ints,
kaya na namin tukuyin ang mga partikular na pag-uugali sa loob ng itim na kahon.
Kaya i-pause ang video.
At tumagal ng mas maraming oras kailangan mong subukan at tukuyin
isang pagpapatupad ng magdagdag ng dalawang ints, tulad na kapag ang pag-andar output ng isang halaga,
ito ay, sa katunayan, return ang kabuuan ng dalawang input.
Kaya tulad ng mga nakaraang mga halimbawa, may mga ilang iba't-ibang paraan
na maaari mong ipatupad magdagdag ng dalawang ints.
Narito ang isa.
Sa dito sa orange na ko lamang ay nagkaroon ng ilang comments--
Lamang Nagdagdag ako ng ilang mga Tingnan ang mga komento upang ipahiwatig
ano ang nangyayari sa bawat linya ng code.
Kaya Ipinahahayag ko sa isang variable tinatawag na kabuuan ng uri int.
Sinasabi ko sum ay katumbas ng isang plus b.
Iyon ay kung saan aktwal na aming ginagawa ang gawain ng pagdagdag ng isang at b magkasama.
At bumalik ako sum.
At na akma dahil sum ay isang variable ng uri int.
At kung ano ang uri ng data na ito Sinasabi sa akin ng function ito ay pagpunta sa output?
Int.
Kaya ako bumabalik kabuuan, na ay isang integer variable.
At na ang akma na ibinigay kung ano na namin ipinahayag at tinukoy aming mga function
gagawin.
>> Ngayon ay maaari mo ring tukuyin ang ang function ganitong paraan,
int sum ay katumbas ng isang plus b-- laktawan na unang step-- at pagkatapos, bumalik sum.
Maaari ka na ngayong magkaroon din ng ipinatupad ito sa ganitong paraan,
kung saan ko mataas ay hindi inirerekomenda.
Ito ay masama estilo para sa isa bagay at ganap na hindi maayos na disenyo,
ngunit ito ay, sa katunayan, work.
Kung ikaw ay kumuha ng code, na kung saan ay int magdagdag ng masamang ahas dot c, at gamitin ito.
Ito talaga ay si dalawang integer magkasama.
Ito ay isang lubhang mahirap na pagpapatupad ng partikular na pag-uugali.
Ngunit ito ay hindi gumagana.
Ito ay lamang dito upang ilarawan sa punto na hindi namin talagang
pakialam kung ano ang mangyayari sa loob ang itim na kahon, hangga't
dahil ito ay ang output na inaasahan namin.
Ito ay isang mahinang dinisenyo itim na kahon.
Ngunit sa pagtatapos ng araw, ito ay pa rin output ang kabuuan ng isang plus b.
Lahat tama.
Kaya ipinahayag na namin ang pag-andar.
At tinukoy namin ang function.
Kaya na talagang mahusay.
Ngayon natin simulan na gamitin ang mga function hayaan na iyong ipinahayag namin at na tinukoy namin.
Upang tawagan ang isang function ito ay aktwal na pretty easy-- lahat ng kailangan mong gawin
ay pumasa ito naaangkop arguments, argumento ng uri ng data
na ito inaasahan, at pagkatapos ay italaga ang return
halaga ng na function at this-- excuse me--
magtalaga ng mga halaga ng pagbabalik ng na function na sa isang bagay ng tamang uri.
>> Kaya sabihin magkaroon ng isang pagtingin sa ito sa pagsasanay sa isang file
tinatawag na ulupong 1 dot c, na kung saan Mayroon akong sa aking cs50 IDE.
Kaya dito ay ang nagsasama 1 dot c.
Sa simula nakikita ninyo sa akin aking kinabibilangan, pound isama,
standard IO, at cs50 dot h.
At pagkatapos ay ako ang aking function deklarasyon.
Ito ay kung saan ako nagsasabi ng compiler Ako
pagpunta sa pagsulat ng isang function na tinatawag na magdagdag ng dalawang ints.
Ito ay pagpunta sa output ng isang integer uri ng variable.
Iyan ang bahagi na ito ay karapatan dito.
At pagkatapos ay mayroon akong dalawang input na ito ng isang at b, ang bawat isa ay isang integer.
Inside ng main, hinihiling ko ang mga user para sa input sa pagsasabing, bigyan ako ng isang integer.
At ang mga ito ay na-prompt upang makalimutan int, na kung saan ay isang function na
ay kasama sa cs50 library.
At na ay makakakuha ng naka-imbak sa x, na isang integer variable.
>> Pagkatapos i-prompt namin ang mga ito para sa isa pang integer.
Kumuha kami ng isa pang integer at mag-imbak na sa y.
At pagkatapos, dito sa 28 na linya, ay kung saan ang aming tawag function.
Kami ay sinasabi, int z equals magdagdag ng 2 ints x comma y.
Huwag mong makita kung bakit ito ang akma?
x ay isang uri ng integer variable at y ay isang uri ng integer variable.
Kaya na mabuti.
Na magkaroon ng kahulugan sa kung ano ang aming mga function deklarasyon sa 17 linya kamukha.
Ang comma separated list input Inaasahan ng dalawang integer, isang at b.
Sa kasong iyon, maaari naming tumawag ano man ang mga ito ang gusto namin.
Inaasahan lamang ay dalawang integer.
At x ay isang integer at y ay isang integer.
Na gumagana.
>> At nalalaman natin na ang function ay pagpunta na output ng isang integer rin.
At kaya pagtatabi namin ay ang output ng function,
magdagdag ng dalawang mga ints, sa isang uri ng integer variable, na kung saan kami ay pagtawag z.
At pagkatapos ay maaari naming sabihin, ang kabuuan ng porsiyento i at porsiyento i ay i porsyento.
x, y at z ayon sa pagkakabanggit pagpuno sa mga porsiyento i ni.
Ano ang kahulugan ng magdagdag ng hitsura ng dalawang ints gusto?
Ito ay medyo simple.
Ito ay isa sa mga tayo Nakita lamang ng isang segundo na nakalipas,
katumbas int sum ng plus return b sum.
Gumagana ba ito?
I-save ng file Hayaan.
At pagkatapos ay down na dito sa aking terminal Pupunta ako sa gumawa ng ulupong 1,
at i-clear ang aking screen.
Pupunta ako upang mag-zoom in dahil alam ko ito ay isang maliit na mahirap makita.
>> Kaya compile namin ang program na ito bilang ulupong 1.
Kaya maaari naming gawin dot slash ulupong 1.
Bigyan mo ako ng isang integer, 10.
Bigyan mo ako ng isa pang integer, 20.
Ang kabuuan ng 10 at 20 ay 30.
Kaya gumawa kami ng isang matagumpay na pag-andar ng tawag.
Maaari mong patakbuhin muli ang function, negatibong 10, 17 kabuuan ng mga negatibong 10 at 17 ay 7.
Gumagana ang function na ito.
Ito ay ang pag-uugali na inaasahan namin ito sa.
At kaya ginawa naming ng isang matagumpay na function, kahulugan, pagpapahayag,
at ang isang matagumpay na tawag function.
Ilang mga iba't ibang puntos tungkol sa mga pag-andar
bago naming tapusin ang seksyong ito.
Pagpapabalik mula sa aming talakayan ng mga uri ng data,
dati, na ang mga function maaring magtagal walang input.
Kung iyon ang kaso, kami Ipinahahayag ng mga function
tulad ng pagkakaroon ng isang listahan na walang bisa argument.
Natatandaan mo pa ba kung ano ang mga pinaka-karaniwang pag-andar
nasaksihan namin sa ngayon na tumatagal isang listahan argument void ay?
Ito ay pangunahing.
Alalahanin din na ang function na kung minsan hindi tunay na may isang output.
Sa kasong iyon, ipinapahayag namin ang function tulad ng pagkakaroon ng isang uri void return.
Tapusin ni seksyon na ito sa pamamagitan ng Hayaan tackling isang problema practice.
>> Kaya narito ang problema inilatag.
Gusto ko sa iyo na magsulat ng isang function tinatawag valid triangle.
Ano ang dapat gawin ang function na ito ay tumagal ng tatlong tunay na mga numero
na kumakatawan sa haba ng tatlong panig ng isang tatsulok bilang parameter nito,
o mga argument nito, o ang kanyang inputs-- isa pang hanay ng mga kasingkahulugan
na maaari mong nakakaharap.
Ang pagpapaandar na ito ay dapat na mag-output totoo o hindi
depende sa kung ang tatlong haba mga ay may kakayahang gumawa ng isang tatsulok.
Naaalala mo ba ang uri ng data na ginamit namin upang ipahiwatig kung tama o mali?
Ngayon paano mo ipatupad ito?
Well alam may isang pares ng mga patakaran tungkol sa triangles
na ang mga tunay na kapaki-pakinabang na malaman.
Ang tatsulok ay maaari lamang magkaroon panig na may positibong haba.
Na makatuwiran.
Marahil ang iyong sinasabi, duh.
Ang iba pang mga bagay na dapat tandaan bagaman, ay na ang kabuuan
ng haba ng anumang dalawang panig ng tatsulok
ay dapat mas malaki kaysa sa haba ng ikatlong panig.
Iyan ay talagang totoo.
Hindi ka maaaring magkaroon ng isang tatsulok panig 1, 2 at 4, halimbawa, dahil 1 plus 2
ay hindi mas malaki kaysa sa 4.
Kaya ang mga ay ang mga tuntunin na matukoy kung o hindi ang tatlong
input ay maaaring naiisip bumuo ng isang tatsulok.
Kaya maglaan ng ilang minuto at ipinapahayag at pagkatapos ay tukuyin ang
mga function na ito na tinatawag na valid tatsulok, tulad na ito ay tunay na
ay ang pag-uugali na tinukoy dito.
>> Ito ay output totoo kung ang mga tatlong panig ay kaya ng na binubuo ng isang tatsulok,
at maling kung hindi man Handa upang makita kung paano ang iyong ginawa?
Narito ang isa pagpapatupad ng valid triangle.
Ito ay hindi lamang ang isa.
Maaaring Taos-iba nang bahagya.
Ngunit ang isang ito ay, sa katunayan, ay may ang pag-uugali na inaasahan namin.
Ipinapahayag namin ang aming mga function sa pinakatuktok, bool valid tatsulok
lumutang x float y float z.
Kaya muli, ang function na ito tumatagal ng tatlong tunay na mga numero
bilang argumento nito, lumulutang variable na halaga ng point,
at lumilikha ng isang true o false halaga, na kung saan ay isang Boolean, pagpapabalik.
Kaya na ang dahilan kung bakit ang uri ng return ay bool.
Pagkatapos namin tukuyin ang mga function.
Unang bagay na namin ay suriin upang tiyakin na na ang lahat ng panig ay positibo.
Kung x ay mas mababa sa o katumbas ng sa 0, o kung y ay katumbas ng 0,
o kung z mas mababa sa o katumbas ng 0, na hindi maaaring posibleng maging isang tatsulok.
Hindi sila ay may positibong panig.
At upang maaari naming bumalik false na sa sitwasyon.
Susunod, tingnan nating tiyakin na ang bawat pares ng mga input
ay mas malaki kaysa sa ikatlong isa.
>> Kaya kung x plus y ay mas mababa kaysa sa o katumbas z,
o kung x plus z ay mas mababa kaysa sa o katumbas ng y,
o kung y plus z ay mas mababa sa o katumbas ng x, na rin ay hindi maaaring maging isang wastong triangle.
Kaya bumalik kami false muli.
Sa pag-aakala namin ang pumasa sa parehong mga tseke bagaman, pagkatapos ay maaari naming nagbabalik ng tunay.
Dahil ang mga tatlong panig kaya ng returning--
ng paglikha ng isang valid na tatsulok.
At na ito.
Ngayon ko na ipinahayag mo at tinukoy.
At maaaring ikaw ay maaaring sa ngayon gamitin at tawagin ang function na ito.
Mahusay.
Ako Doug Lloyd.
Ito ang cs50.