DOUG LLOYD: Okay.
Så lad os nu tackle en virkelig stort emne, funktioner.
Indtil videre i løbet, hele programmer, som vi har skrevet
Der er skrevet inde i main.
De er temmelig simple programmer.
Du behøver ikke at have alle disse filialer og ting foregår.
Vi kan bare passe det hele indersiden af ​​primære og det
ikke får forfærdelig overvældende.
Men da forløbet går på og når du begynder at udvikle programmer
uafhængigt af hinanden, er de sandsynligvis vil at begynde at få en masse mere end 10
eller 15 linjer.
Du kan få hundredvis eller tusindvis eller titusinder af linjer kode.
Og det er virkelig ikke den skøre en tanke.
Som sådan, er det nok ikke en god idé at holde alt inde i main.
Det kan få en smule vanskeligt at finde hvad du leder efter, hvis du gør det.
>> Heldigvis, selvom C og temmelig meget hver anden programmeringssprog,
kunne arbejde med, giver os om at skrive funktioner.
Og jeg er bare at gå til tage en hurtig side her
at nævne, at funktioner er et område af datalogi.
Og du vil se mange flere af dem på forskellige punkter i hele forløbet
og hvis du fortsætter på.
Hvor der er en masse synonymer for det samme ord.
Så vi kalder funktionerne.
Men du kan også høre dem benævnt procedurer,
eller metoder, især, hvis du har nogensinde gjort nogen objektorienteret programmering
before-- og ikke bekymre dig hvis du ikke har, ikke
en stor deal-- men revision orienterede sprog
ofte kaldet metoder.
Sommetider de kaldes underrutiner.
Men de virkelig refererer alle til den samme grundlæggende idé.
>> Lad os se, hvad denne idé er.
Hvad er en funktion?
Nå en funktion er virkelig intet mere end en sort boks.
En sort boks, der har et sæt på nul eller flere indgange og en enkelt udgang.
Så for eksempel, kunne være en funktion.
Dette er en funktion kaldet funk.
Og det tager tre indgange a, b, c og.
Og indeni, sorte boks, vi ved ikke præcis, hvad den gør,
men den behandler de input på en eller anden måde, og så er det
giver et enkelt output, i dette tilfælde, z.
Nu for at gøre det lidt mindre abstrakt, vi
kunne sige, at vi måske har en funktion kaldet
tilføje, at tager tre indgange a, b, og c og behandler outputtet på nogen måde
inde den sorte boks til producere et enkelt output.
Så i dette tilfælde, hvis tilføj tager 3, 6 og 7.
Et eller andet sted inde i tilføje funktionen, vi ville
forventer, at lægges sammen at producere output, som
er 3 plus 6 plus 7 eller 16.
>> På samme måde har du en funktion kaldet mult der tager to indgange, a og b,
behandler dem på en eller anden måde, således at produktionen af ​​funktionen
er produktet af de to indgange.
De to indgange ganget sammen.
4 og 5 bliver passeret ind mult, sker noget, output vi forventer
20.
Hvorfor skal vi kalde det en sort boks?
Tja, hvis vi ikke skrive fungerer os selv, som
vi har gjort en hel del hidtil CS50.
Vi har set print f, for eksempel, som er en funktion, som vi ikke skriver
os selv, men vi bruger hele tiden.
Hvis vi ikke skriver de funktioner, os selv,
vi ikke virkelig har brug for at vide, hvordan det er faktisk iværksat under kølerhjelmen.
>> Så for eksempel den sorte boks I bare viste dig for multiplikation,
mult a, kunne b være defined-- og det er bare
nogle pseudocode-- kunne være defineret som output gange b.
Det mening, højre.
Hvis vi har en funktion kaldet mult der tager to indgange.
Vi forventer, at produktionen ville være de to indgange multipliceret sammen,
a gange b.
Men mult kunne også være implementeres som dette,
vi har en tæller variabel til få sat inde i mult til 0.
Og så skal vi gentage denne proces b gange føje en til tæller.
For eksempel, hvis vi ganger 3a af 5b, vi kunne sige sat imod 0,
gentag fem gange, tilsættes 3 til tælleren.
Så vi starter på 0 og så gør vi dette fem gange 3, 6, 9, 12, 15.
Det er det samme resultat. Vi stadig få 3 gange 5 bare
implementeringen er anderledes.
>> Det er, hvad vi mener når vi siger en sort boks.
Det betyder blot, at vi ikke rigtig pleje hvordan det er implementeret under kølerhjelmen
så længe produktionen er, hvad vi forventer.
Faktisk, det er en del af kontrakten for at anvende funktioner, især
funktioner, som andre skriver.
Adfærden er altid vil at være typiske, uforudsigelige
baseret på funktionens navn.
Og det er derfor, det er virkelig vigtigt, når man skriver funktioner
eller når andre folk skriver funktioner, som du kan bruge,
at disse funktioner har klare, relativt indlysende navne,
og er veldokumenterede.
Hvilket er helt sikkert tilfældet for funktion som print f.
>> Så hvorfor skal vi bruge funktioner?
Nå som jeg sagde tidligere, hvis vi skriver alle vores kode inde af de vigtigste ting
kan få virkelig besværligt og virkelig kompliceret.
Funktioner tillader os evnen at organisere ting og bryde op
et meget kompliceret problem ind meget mere håndterbare sub dele.
Funktioner også tillade os at forenkle kodningsprocessen.
Det er meget nemmere at fejlsøge en 10 linjefunktion versus en 100 linie
funktion eller en 1.000 linje funktion.
Hvis vi kun har til debug små stykker ad gangen,
eller skrive små stykker på det tidspunkt, det gør, at programmeringserfaring
meget bedre.
Tro mig på at en.
>> Endelig, hvis vi skriver funktioner vi kan genbruge disse forskellige dele.
Funktioner kan genbruges.
De kan anvendes i et eller andet program.
Du har allerede skrevet den funktion, alt hvad du
skal gøre er fortælle, at programmet hvor man kan finde denne funktion.
Vi har genbrug og hjælp udskrive f i over 40 år.
Men det blev kun skrevet én gang.
Temmelig anvendelige, højre.
Okay.
Så funktioner er stor.
Vi ved, at.
Lad os nu begynde at skrive dem.
Lad os begynde at få dem ind i vores programmer.
For at gøre det, den første ting, vi gør, er at erklære funktionen.
Når du erklærer en funktion hvad du dybest set gør
fortæller compileren, hey, bare så du ved,
Jeg kommer til at skrive en funktion senere
og her er hvad det kommer til at se ud.
Grunden til dette er fordi compilere kan
gøre nogle underlige ting, hvis de ser et sæt af symboler
at de ikke er bekendt med.
Så vi bare give den compiler en heads up, jeg skaber en funktion
og det kommer til at gøre dette.
Funktion erklæringer generelt hvis du organisere din kode på en måde,
at andre vil kunne forstå og gøre brug af,
du generelt ønsker at sætte alle af din funktion erklæringer
på selve toppen af ​​din kode, højre før du begynder at skrive vigtigste selv.
Og bekvemt, der er en meget standardformular
at enhver funktion Erklæringen følger.
De alle temmelig meget se sådan ud.
Der er tre dele til en funktion erklæring, returtype, navn,
og argumentet listen.
>> Nu afkastet type er, hvad slags variabel funktionen udsendes.
Så for eksempel, hvis vi tænker tilbage minut siden til at gange to
tal-funktion, hvad forventer vi, hvis vi ganger et helt tal med et tal,
output vil være sandsynligvis et heltal, højre.
Ganget to heltal sammen, får du et heltal.
Så returtypen af ​​denne funktion ville være int.
Navn er, hvad du vil at ringe til din funktion.
Dette er sandsynligvis den mindst vigtige del af funktionserklæringen,
med hensyn til funktionalitet.
Men er faktisk nok en af de vigtigste dele
af funktionen erklæring i form at vide, hvad den funktion faktisk
gør.
Hvis du navngiver din funktion f eller g eller h eller mystik eller noget lignende,
du sandsynligvis vil få lidt udløst at forsøge
at huske, hvad disse funktioner gør.
Så det er vigtigt at give din funktionens meningsfulde navne.
>> Endelig argumentliste er den kommasepareret liste
af alle input til din funktion, der hver især har en type og et navn.
Så ikke nok med at du er nødt til at angive, hvilken type variabel
Funktionen output, du også ønsker at specificere
hvilken type og typer af variabler de Funktionen vil acceptere som input.
Så lad os gøre et eksempel her.
Lad os bare tage et kig ved en mere konkret en.
Så her er et eksempel på en funktion erklæring for en funktion, der
ville tilføje to heltal sammen.
Summen af ​​to tal vil være et heltal samt, som vi lige
diskuteret.
Og så afkastet type, her i grønt, ville være int.
Der bare fortæller os, at tilføje to ints vil, ved slutningen af ​​dagen,
output eller spytte den tilbage ud til os, et heltal.
I betragtning af, hvad denne funktion gør vi ønsker at give det et meningsfuldt navn.
Tilføj to ints synes hensigtsmæssigt i betragtning
vi tager to heltal som input og forhåbentlig tilføje dem sammen.
Det kan være lidt af en besværlig navn og helt ærligt denne funktion
er sandsynligvis ikke nødvendig da vi har tilføjelsen
operatør, hvis du husker fra vores diskussion af operatører, der tidligere.
Men lad os bare sige til skyld argument om, at denne funktion er nyttig
og så vi vil kalde det tilføje to ints.
Endelig denne funktion tager to indgange.
Som hver især er et helt tal.
Så vi har denne komma adskilt liste af input.
Nu vi generelt ønsker at give et navn til hver af dem
således at de kan anvendes i funktionen.
Navnene er ikke frygtelig vigtig.
>> I dette tilfælde har vi ikke nødvendigvis har nogen betydning knyttet til dem.
Så kan vi bare kalde dem a og b.
Det er helt fint.
Hvis du imidlertid finde dig selv i en situation,
hvor navnene på de variable kan faktisk være vigtigt,
du måske ønsker at kalde dem noget andet end a og b
at give dem noget mere symbolsk meningsfuldt.
Men i dette tilfælde, har vi ikke rigtig vide noget andet om funktion.
Vi vil blot tilføje to heltal.
Så vi vil bare kalde disse tal a og b.
Det er et eksempel.
>> Hvorfor tager du ikke tage en anden at tænke på denne ene,
hvordan ville du skriver en funktion erklæring for en funktion, der
ganger to floating point tal?
Kan du huske, hvad en decimaltal er?
Hvad ville denne funktion erklæring ud?
Jeg faktisk anbefale dig at holde pause videoen her og tage, hvor meget tid du har brug for.
Tænk over, hvad dette funktion erklæring ville være?
Hvad ville afkastet typen være?
Hvad ville en meningsfyldt navn være?
Hvad ville indgangene være?
Så hvorfor du ikke holde pause i videoen her og skrive-up en funktion erklæring
for en funktion, der ville formere to flydende komma tal sammen.
Forhåbentlig du standsede videoen.
>> Så lad os tage et kig på et eksempel af en mulig erklæring.
Float mult to reals flyde x, float y.
Produktet af to flydende tal,
som husker er, hvordan vi repræsentere reelle tal
eller tal med decimalværdier i C, vil være et decimaltal.
Når du ganger en decimal af en decimal,
du sandsynligvis vil få en decimal.
Du ønsker at give det et relevant navn.
Formere to reals virker fint.
Men du virkelig kunne kalde det mult to flydere eller mult flåd.
Noget lignende, så længe det gav nogle egentlige betydning til hvad
denne sorte boks ville gøre.
Og igen, i dette tilfælde, har vi ikke synes at have nogen betydning knyttet
til navnene på de variabler, vi passerer i,
så vi bare kalde dem x og y.
Nu, hvis du kalder dem noget andet, det er helt fint.
Faktisk, hvis du gjorde denne erklæring i stedet
hjælp doubler i stedet af flåd, hvis du husker
at double er en anden måde at mere præcist
specificere reelle tal eller floating point variabler.
Det er helt fint også.
Enten en af ​​dem ville være fint.
I virkeligheden er der flere forskellige kombinationer
måder at erklære denne funktion.
Men det er to temmelig gode.
Vi har erklæret en funktion, det er fantastisk.
Vi har fortalt compiler, hvad det er, hvad vi skal gøre.
Lad os nu rent faktisk at skrive denne funktion.
Lad os give det en definition, så inde den sorte boks
forudsigelig adfærd, der sker.
Faktisk er vi multiplicere to real tal sammen, eller tilføje numre
sammen, eller gør, hvad det er at vi spurgte vores funktion at gøre.
>> Så i virkeligheden, lad os prøve og definere formere to reals, som vi netop
talte om en anden siden.
Nu begyndelsen af en funktion definition
ser næsten nøjagtigt det samme som en funktion erklæring.
Jeg har dem begge her.
Øverst er den funktion erklæring, type, navn, kommasepareret argument
listen, semikolon.
Semikolon viser, at som er en funktion erklæring.
Begyndelsen af ​​funktionen definition ser næsten præcis
den samme, type, navn, kommasepareret argument liste, ingen semikolon,
åbne krøllede klammeparentes.
Den åbne krøllede bandage, ligesom vi har gjort med de vigtigste,
betyder, at vi nu er begynder at definere
hvad der sker inde i sorte boks, der vi har besluttet at kalde mult to reals.
Her er en måde at gennemføre den.
Vi kunne sige, at vi kunne erklære en ny variabel af typen float kaldet produkt
og tildele den pågældende variabel til værdien x gange y.
Og derefter vende tilbage produkt.
Hvad betyder tilbagevenden mener her.
Nå afkast er den måde vi angiver, er, hvordan
vi passerer output bakke ud.
Så returnere noget, er den samme som, dette er outputtet af den sorte boks.
Så det er hvordan du gør det.
Her er en anden måde at gennemføre den.
Vi kunne bare vende tilbage x gange y.
x er en svømmer.
y er en svømmer.
Så x gange y er også en flyder.
Vi behøver ikke engang at oprette en anden variabel.
Så det er en anderledes måde at gennemføre nøjagtig samme sorte boks.
>> Nu tage et øjeblik, pause videoen igen,
og prøv og definere tilføje to ints, som er den anden funktion, som vi
talte om for et øjeblik siden.
Igen her, jeg har lagt den funktion erklæring, og så semikolon,
og en åben krøllet tandbøjle og en lukket krøllet
tandbøjle til at angive, hvor vi vil fylde i indholdet af tilføje to ints,
så vi definerer de særlige adfærd inde i sorte boks.
Så pause videoen.
Og tage så meget tid som du nødt til at forsøge at definere
en implementering af add to ints, såsom at når funktionen afgiver en værdi,
det gør i virkeligheden, afkast Summen af ​​de to indgange.
Så ligesom det foregående eksempel, Der er flere forskellige måder
at man kunne implementere tilføje to ints.
Her er en.
Herinde i orange har jeg lige haft nogle comments--
Jeg har lige tilføjet nogle kommentarer for at indikere
hvad der sker på hver linje kode.
Så jeg erklærer en variabel kaldes summen af ​​typen int.
Jeg siger sum lig et plus b.
Det er, hvor vi rent faktisk gør arbejdet tilføje A og B tilsammen.
Og jeg vender tilbage sum.
Og det giver mening, fordi sum er en variabel af typen int.
Og hvad er de data, skriver, at dette Funktionen fortæller mig det kommer til at output?
Int.
Så jeg vender tilbage sum, som er en heltalsvariabel.
Og det giver mening givet, hvad vi har erklæret og defineret vores funktion
at gøre.
>> Nu kan du også definere funktionen denne måde,
int sum lig et plus B-- springe, at først step-- og derefter returnere summen.
Nu kunne du også have implementeret det på denne måde,
som jeg stærkt anbefaler ikke.
Det er skidt stil for én ting og virkelig dårligt design,
men det gør faktisk arbejde.
Hvis du tager denne kode, som er int tilføje dårlig adder dot c, og bruge det.
Det faktisk gør tilføje to heltal sammen.
Det er en meget dårlig gennemførelse af denne særlige adfærd.
Men det virker.
Det er bare her for at illustrere det punkt, at vi ikke rigtig
ligeglad med, hvad der sker inde den sorte boks, så længe
som det har output, som vi forventer.
Dette er en dårligt konstrueret sort boks.
Men i slutningen af ​​dagen, det gør stadig output summen af ​​et plus b.
Okay.
Så vi har erklæret funktioner.
Og vi har defineret funktion.
Så det er virkelig godt.
Lad os nu begynde at bruge funktionerne at vi har erklæret, og vi har defineret.
At kalde en function-- er det faktisk temmelig easy-- alt du behøver at gøre
er passere det passende argumenter, argumenter for datatypen
at det forventer, og derefter tildele afkastet
Værdien af ​​denne funktion og her-- undskyldning mig--
tildele returværdien af ​​denne funktion til noget af den korrekte type.
>> Så lad os få et kig på det i praksis i en fil
kaldet adder 1 dot C, som Jeg har i min CS50 IDE.
Så her er adder 1 dot c.
I begyndelsen ser du, jeg har min indbefatter pund omfatter,
standard IO og CS50 dot h.
Og så har jeg min funktion erklæring.
Det er her, jeg er fortæller compileren jeg
vil være at skrive en funktion kaldet tilføje to ints.
Det kommer til at afgive et heltalstype variabel.
Det er, hvad denne del er lige her.
Og så har jeg to indgange til det en og b, som hver især er et helt tal.
Inde i main, spørger jeg brugeren om input ved at sige, giv mig et heltal.
Og de bliver bedt om at glemme int, som er en funktion, der
er inkluderet i CS50 biblioteket.
Og der bliver lagret i X, en heltalsvariabel.
>> Så vi beder dem til en anden heltal.
Vi får en anden heltal og gemme det i y.
Og så, her på linje 28, er hvor vi gør vores funktion opkald.
Vi siger, int z ligemænd tilføje 2 ints x komma y.
Kan du se, hvorfor det giver mening?
x er et heltal variabel af og y er et heltal typen variabel.
Så det er godt.
Det mening med, hvad vores funktion erklæring on line 17 ser ud.
Den kommasepareret input liste forventer to heltal, a og b.
I dette tilfælde kan vi kalder dem, hvad vi ønsker.
Det forventer bare to heltal.
Og x er et helt tal, og y er et helt tal.
Der virker.
>> Og vi ved, at funktionen går til udsendelse af et heltal så godt.
Og så er vi opbevare output af funktionen,
tilføje to ints, i en heltalstype variabel, som vi kalder z.
Og så kan vi sige, at summen af procent i og procent i er procent i.
x, y og z henholdsvis udfylde dem procent vigtigst.
Hvad er definitionen af tilføje to ints se ud?
Det er ret simpelt.
Det er en af ​​dem, vi lige set en anden siden,
int sum lig et plus b afkast sum.
Fungerer det?
Lad os gemme filen.
Og derefter ned her på min terminal Jeg har tænkt mig at gøre adder 1,
og jeg rydde min skærm.
Jeg har tænkt mig at zoome ind, fordi jeg ved det er lidt svært at se.
>> Så vi kompilere dette program som adder 1.
Så vi kan gøre dot skråstreg adder 1.
Giv mig et heltal, 10.
Giv mig en anden heltal, 20.
Summen af ​​10 og 20 er 30.
Så vi lavede en vellykket funktionskald.
Du kan køre funktionen igen, negativ 10, 17 Summen af ​​negativ 10 og 17 er 7.
Denne funktion fungerer.
Det har adfærd at vi forventer, at det.
Og så har vi lavet en vellykket funktion, definition, erklæring,
og en vellykket funktionskald.
Par diverse punkter om funktioner
før vi konkludere dette afsnit.
Husker fra vores diskussion af datatyper,
tidligere, at funktioner kan nogle gange tage nogen indgange.
Hvis det er tilfældet, vi erklære funktionen
som havende en liste void argument.
Kan du huske, hvad den mest almindelige funktion
vi har set hidtil, der tager et tomrum argument liste er?
Det vigtigste.
Husk også, at funktionen nogle gange faktisk ikke har en udgang.
I så fald erklærer vi funktionen som havende en void returtype.
Lad os slutte dette afsnit af tackle en praksis problem.
>> Så her er det lagt ud problemet.
Jeg vil have dig til at skrive en funktion kaldes gyldige trekant.
Hvad denne funktion bør gøre er at tage tre reelle tal
som repræsenterer længderne af de tre sider af en trekant, som dens parametre,
eller sine argumenter, eller dens inputs-- andet sæt synonymer
at du kan støde på.
Denne funktion bør enten udgang sandt eller falsk
afhængigt af, om disse tre længder er i stand til at gøre en trekant.
Kan du huske den datatype, Vi bruges til at angive sande eller falske?
Nu hvordan kan du gennemføre denne?
Nå ved, der er et par af reglerne om trekanter
der er faktisk nyttigt at vide.
En trekant kan kun have sider med positiv længde.
Det giver mening.
Du er sikkert at sige, duh.
Den anden ting at bemærke er imidlertid, at summen
af længderne af alle to sider af trekanten
skal være større end den længden af ​​den tredje side.
Det er faktisk sandt.
Du kan ikke have en trekant af siderne 1, 2 og 4, for eksempel, fordi 1 plus 2
ikke er større end 4.
Så det er de regler, der afgøre, om tre eller ikke
indgange kan tænkes at danne en trekant.
Så tag et par minutter og erklære og derefter definere
denne funktion kaldes gyldige trekant, således at det faktisk
har adfærden angivet her.
>> Det vil output sandt, hvis disse tre sider er i stand til omfattende en trekant,
og ellers false Klar til at se, hvordan du gjorde?
Her er en implementering af gyldige trekant.
Det er ikke den eneste.
Med venlig kan variere en smule.
Men dette gør, i virkeligheden har den adfærd, vi forventer.
Vi erklærer vores funktion på helt i top, bool gyldigt trekant
flyde x float y float z.
Så igen, denne funktion tager tre reelle tal
som sine argumenter, flydende punkt værdi variabler,
og udsender et sandt eller falsk værdi, som er en boolesk, tilbagekaldelse.
Så det er derfor afkastet type er bool.
Så vi definere funktionen.
Første ting vi gør, er tjekke for at sikre at alle siderne er positive.
Hvis x er mindre end eller lig til 0, eller hvis y er lig med 0,
eller hvis z er mindre end eller lig med 0, der kan umuligt være en trekant.
De har ikke positive sider.
Og så vi kan vende tilbage falsk i den situation.
Næste vi kontrollere, at at hvert par indgange
er større end den tredje.
>> Så hvis x plus y er mindre end eller lig med z,
eller hvis X plus Z er mindre end eller lig med y,
eller hvis y plus z er mindre end eller lig med x, der også kan ikke være en gyldig trekant.
Så vi return false igen.
Hvis man antager, vi passerede begge kontroller selv, så kan vi vende tilbage sandt.
Fordi disse tre sider er i stand til returning--
for at skabe en gyldig trekant.
Og det er det.
Du har nu erklæret og defineret.
Og du kan være i stand til nu bruge og kalder denne funktion.
Godt arbejde.
Jeg er Doug Lloyd.
Det er CS50.