DOUG LLOYD: Oké.
Dus laten we nu aan te pakken een echt groot onderwerp, functies.
Tot nu toe tijdens alle programma's die we hebben schrijven
zijn geschreven binnenkant van de belangrijkste.
Ze zijn vrij eenvoudig programma.
U hoeft niet om al deze hebben takken en dingen gaande.
We kunnen gewoon fit het allemaal binnenzijde van de belangrijkste en
krijgt niet erg overweldigend.
Maar als de cursus gaat op en als je begint om programma's te ontwikkelen
onafhankelijk van elkaar, zijn ze waarschijnlijk gaan om te beginnen met een veel meer dan 10 krijgen
of 15 lijnen.
Je zou kunnen honderden of duizenden krijgen of tienduizenden regels code.
En het is echt niet die gekke gedachte.
Als zodanig is het waarschijnlijk geen goed idee alles binnenin main houden.
Het kan een beetje moeilijk te vinden wat je zoekt als je dat doet.
>> Gelukkig, hoewel C, en vrij veel elke andere programmeertaal die
misschien met werken, laat wij functies schrijven.
En ik ga gewoon neem snel opzij hier
te vermelden dat functies is een gebied van de informatica.
En je zult nog veel meer van hen op te zien verschillende punten in de loop
en als je verder op.
Waar er een heleboel synoniemen voor hetzelfde woord.
Dus noemen we de functies.
Maar je zou ook hen te horen genoemd procedures
of methoden, in het bijzonder, als je ooit gedaan een object georiënteerd programmeren
before-- en maak je geen zorgen Als u nog niet, niet
een grote Deal-- maar in audit georiënteerde talen
vaak genoemd methoden.
Soms zijn ze subroutines genoemd.
Maar ze echt allemaal verwijzen dezelfde basisgedachte.
>> Laten we eens kijken wat dat idee is.
Wat is een functie?
Ook een functie is echt niets meer dan een black box.
Een zwarte doos die een reeks van nul heeft of meer ingangen en een uitgang.
Dus bijvoorbeeld, deze kan een functie zijn.
Dit is een functie genaamd func.
En er zijn drie ingangen a, b en c.
En in die black box, we weet niet precies wat het doet,
maar verwerkt de inputs op een bepaalde manier en dan
geeft een uitgang, in dit geval, z.
Nu het een beetje te maken minder abstract, we
kan misschien zeggen dat we een functie genaamd
toevoegen dat duurt drie ingangen a, b, en c en verwerkt de uitvoer op een bepaalde manier
in de zwarte doos aan produceren een uitgang.
Dus in dit geval, als add neemt 3, 6, en 7.
Ergens in de add-functie, zouden we
verwachten dat ze bij elkaar worden opgeteld de output produceren die
is 3 plus 6 plus 7 of 16.
>> Ook u een functie genaamd hebben mult twee ingangen a en b neemt,
verwerkt daar op een zodanige manier dat de uitgang van de functie
is het product van de twee invoeren.
De twee ingangen met elkaar vermenigvuldigd.
4 en 5 wordt doorgegeven aan mult, er iets gebeurt, de output we verwachten
is 20.
Waarom hebben we noemen het een black box?
Nou als we niet het schrijven van de functioneert onszelf, die
we hebben gedaan nogal een beetje zo ver CS50.
We hebben druk f gezien, bijvoorbeeld, die is een functie die we niet schrijven
onszelf, maar we gebruik maken van alle tijd.
Als we niet schrijven de functies onszelf,
we niet echt nodig om te weten hoe het is daadwerkelijk ten uitvoer gelegd onder de motorkap.
>> Dus bijvoorbeeld de zwarte doos I gewoon toonde u voor vermenigvuldiging,
mult a, b kan worden defined-- en dit is slechts
sommige pseudocode-- zou kunnen zijn gedefinieerd als output een keer b.
Dat zinvol, rechts.
Als we een functie genaamd mult dat twee ingangen neemt.
We verwachten dat de output zou zijn de twee ingangen met elkaar vermenigvuldigd,
a keer b.
Mult maar kan ook geïmplementeerd als dit,
We hebben een teller variabele krijgen set binnen van mult op 0.
En dan is dit proces herhalen we b keer toe te voegen aan een teller.
Bijvoorbeeld, als we vermenigvuldigen 3a door 5b, kunnen we zeggen teller op 0,
herhaal vijf keer, voeg 3 tot teller.
Dus beginnen we op 0 en dan doen we Dit vijf maal 3, 6, 9, 12, 15.
Het is het zelfde resultaat. We nog steeds 3 keer 5 net
de uitvoering verschilt.
>> Dat is wat we bedoelen als we zeggen dat een zwarte doos.
Het betekent gewoon dat we niet echt schelen hoe het wordt uitgevoerd onder de motorkap
Zolang de output is wat we verwachten.
In feite, dat is een deel van het contract gebruiken functies, met name
functies die anderen schrijven.
Het gedrag zal altijd typisch, onvoorspelbaar te zijn
op basis van de naam van de functie.
En dat is waarom het echt belangrijk wanneer je schrijft functies
of wanneer andere mensen schrijven functies die u zou kunnen gebruiken,
dat deze functies duidelijk, relatief voor de hand liggende namen,
en zijn goed gedocumenteerd.
Dat is zeker het geval voor de functie zoals print f.
>> Dus waarom gebruiken we functies?
Nou zoals ik al eerder zei, als we schrijven al onze code in van de belangrijkste dingen
kan echt omslachtig en echt ingewikkeld.
Functies laten ons de mogelijkheid om dingen te organiseren en te breken
een zeer ingewikkeld probleem in veel beter beheersbaar sub-onderdelen.
Functies ons ook in staat te stellen de coderende vereenvoudigen.
Het is een stuk makkelijker om te debuggen 10 lijn functie ten opzichte van een 100 lijn
functie of een 1000 lijn functie.
Als we alleen maar te debuggen kleine stukjes tegelijk,
of schrijf kleine stukjes op het moment, het maakt dat de programmering ervaring
een stuk beter.
Geloof me op dat ene.
>> Ten slotte, als we schrijven functies we kunnen deze verschillende onderdelen hergebruiken.
Functies kunnen worden gerecycled.
Ze kunnen worden gebruikt in een programma of andere.
Je hebt al geschreven de functie, alles wat je
hoeft te doen is vertellen dat programma waar die functie te vinden.
We zijn recycling en het gebruik van printen f meer dan 40 jaar.
Maar het was slechts één keer geschreven.
Vrij nuttig, rechts.
Prima.
Dus functies zijn geweldig.
We weten dat.
Laten we nu eens beginnen met het schrijven ze.
Laten we beginnen met het krijgen ze in onze programma's.
Om dat te doen, de eerste wat we doen is te verklaren van de functie.
Wanneer u een functie declareren wat je eigenlijk doet
vertelt de compiler, hey, maar dat je het weet,
Ik ga schrijven een functie later
en hier is wat het gaat eruit.
De reden hiervoor is omdat compilers kan
doe wat rare dingen als zien ze een set van symbolen
dat ze niet vertrouwd zijn.
Dus we geven de compiler een heads-up, ik ben het creëren van een functie
en het gaat om dit te doen.
Functie verklaringen over het algemeen als je bent het organiseren van uw code op een manier
dat anderen in staat zal zijn begrijpen en gebruik maken van,
je over het algemeen willen alle zetten van uw functie declaraties
op de top van je code, rechts voordat u begint met het schrijven van de belangrijkste nog.
En gemakkelijk, er is een zeer standaardformulier
dat elke functie verklaring volgt.
Ze zijn allemaal vrij veel uitzien.
Er zijn drie delen van een functie verklaring, return type, naam,
en de lijst met argumenten.
>> Nu is de return type is wat voor soort variabele zal de functie-uitgang.
Dus bijvoorbeeld, als we denken terug minuten geleden aan de vermenigvuldiging van twee
getallen functie, wat we verwachten als Vermenigvuldigen we een integer van een integer
de output zal zijn waarschijnlijk een integer, rechts.
Vermenigvuldigd twee integers samen, krijg je een integer.
Zodat de return type van die functie zou int.
Naam is wat je wilt uw functie aan te roepen.
Dit is waarschijnlijk het minst belangrijke deel van de functie verklaring
in termen van functionaliteit.
Maar is eigenlijk waarschijnlijk een van de belangrijkste onderdelen
van de verklaring functie in termen te weten wat de functie eigenlijk
doet.
Als u de naam van uw functie f of g of h of mystery of iets dergelijks,
ben je waarschijnlijk gaat krijgen een beetje struikelde up proberen
om te onthouden wat die functies doen.
Dus het is belangrijk om te geven uw betekenisvolle namen functie's.
>> Ten slotte lijst met argumenten is de komma's gescheiden lijst
alle ingangen uw functie, die elk een type en een naam.
Dus niet alleen heb je te specificeren welk type variabele
De functie wordt uitgang, u ook wilt opgeven
wat voor soort en de aard van de variabelen functie accepteren als invoer.
Dus laten we hier een voorbeeld.
Laten we een kijkje nemen een concretere.
Dus hier is een voorbeeld van een functie verklaring voor een functie die
zou twee getallen bij elkaar optelt.
De som van twee getallen gaat zijn een integer als goed, zoals we net
besproken.
En dus is de return type, Hier in groen, zou int.
Dat alleen maar vertelt ons dat twee ints toevoegen gaat, aan het eind van de dag,
uitgang, of spuug het terug naar ons, een integer.
Gezien wat deze functie doet wij willen geven het een betekenisvolle naam.
Voeg twee ints lijkt passend is
we nemen twee integers als input en hopelijk ze samen te voegen.
Het is misschien een beetje omslachtig naam en eerlijk gezegd deze functie
is waarschijnlijk niet nodig want we hebben de toevoeging
operator, als u zich herinneren van onze bespreking van de exploitanten, die eerder.
Maar laten we zeggen omwille van argument dat deze functie is handig
en zo zullen we noemen het toevoegen van twee gehele getallen.
Tot slot, deze functie neemt twee ingangen.
Die elk een integer.
Dus hebben we dit komma gescheiden lijst van inputs.
Nu over het algemeen willen we een naam te geven aan elk van hen
zodat ze kunnen worden gebruikt binnen de functie.
De namen zijn niet erg belangrijk.
>> In dit geval hebben we niet noodzakelijkerwijs enige betekenis aan hen gehecht.
Dus we kunnen gewoon bellen ze a en b.
Dat is helemaal prima.
Als u echter, vind je uzelf in een situatie
waarbij de namen van de variabelen misschien wel belangrijk zijn,
je zou willen om ze te bellen iets anders dan a en b
ze iets meer te geven symbolisch zinvol.
Maar in dit geval hebben we niet echt weet iets anders over de functie.
We willen gewoon twee getallen toe te voegen.
Dus we zullen gewoon bellen deze getallen a en b.
Dat is een voorbeeld.
>> Waarom ga je niet een tweede te nemen na te denken over deze,
hoe zou je een functie schrijven verklaring voor een functie die
vermenigvuldigt twee floating point getallen?
Weet je nog wat een floating point nummer is?
Wat zou deze functie verklaring eruit?
Ik eigenlijk raden je de video pauzeren hier en neem hoeveel tijd je nodig hebt.
Denk na over wat dit functie verklaring zou zijn?
Wat zou het soort terugkeer?
Wat zou een betekenisvolle naam zijn?
Wat zou de ingangen zijn?
Dus waarom ga je niet hier de video te pauzeren en schrijf-up functie verklaring
een functie die zou vermenigvuldigen twee floating point getallen samen.
Hopelijk u de video gepauzeerd.
>> Dus laten we een kijkje nemen op een voorbeeld van een mogelijke verklaring.
Zweven mult twee reals float x, y zweven.
Het product van beide floating point getallen,
die herinneren aan zijn hoe we vertegenwoordigen reële getallen
of nummers met decimale waarden in c, gaat naar een floating point nummer.
Wanneer u vermenigvuldigt een decimaal door een decimaal,
je bent waarschijnlijk gaan om een ​​decimaal te krijgen.
U wilt geven het een relevante naam.
Vermenigvuldig twee reals lijkt in orde.
Maar je kon echt noemen mult twee drijvers, of mult praalwagens.
Iets dergelijks, zolang gaf enkele werkelijke betekenis aan wat
Deze zwarte doos zou gaan doen.
En nogmaals, in dit geval, we doen niet lijkt elke betekenis gehecht aan hebben
de namen van de variabelen die we passeren,
dus we noemen ze x en y.
Nu als je ze iets te bellen anders, dat is helemaal prima.
In feite, als je deed deze verklaring plaats
met behulp van doubles plaats van drijvers, als je herinneren
dat tweepersoonskamers zijn een ander manier om nauwkeuriger
specificeren reële getallen of floating point variabelen.
Dat is ook helemaal prima.
Één van die zou fijn zijn.
In feite zijn er diverse verschillende combinaties
manieren om deze functie te verklaren.
Maar dit zijn twee mooie goede.
We hebben een functie verklaard, dat is geweldig.
We hebben de compiler wat het gezegd wordt, wat we gaan doen.
Laten we nu eigenlijk te schrijven die functie.
Laten we het een definitie, zodat in de zwarte doos
voorspelbaar gedrag gebeurt.
In feite zijn er twee echte vermenigvuldigen getallen met elkaar, of het toevoegen van nummers
samen, of het doen van wat het ook is dat we vroegen ons de functie te doen.
>> Dus in feite, laten we proberen en definieer vermenigvuldigen twee reals die we zojuist
sprak over een seconde geleden.
Nu begin een functie-definitie
ziet er bijna precies hetzelfde als een functie verklaring.
Ik heb beiden hier.
Bovenaan is de functie verklaring , naam, komma's gescheiden argumenten
lijst, puntkomma.
De puntkomma geeft aan dat dat is een functie declaratie.
Het begin van de functie definitie ziet er bijna precies
hetzelfde type, naam, komma's gescheiden lijst met argumenten, geen puntkomma,
Open accolade.
De open accolade, net zoals we hebben gedaan met de belangrijkste,
betekent dat we nu beginnen te definiëren
wat er gebeurt in de zwarte doos die hebben we besloten om mult twee reals noemen.
Hier is een manier om het uit te voeren.
We zouden kunnen zeggen, konden we een nieuwe te verklaren variabele van het type float genoemd product
en wijst die variabele om de waarde x maal y.
En dan terug product.
Wat betekent de terugkeer hier bedoel.
Goed rendement is de weg we geven dat is hoe
we het passeren van de uitgang weer uit.
Zo iets terug, is hetzelfde als, Dit is het uitgangssignaal van de zwarte doos.
Dus dat is hoe je het doet.
Hier is een andere manier om het te implementeren.
We konden gewoon terug x maal y.
x een float.
y een float.
Dus x maal y is een float.
We niet eens nodig om maak een andere variabele.
Dus dat is een andere manier om implementeren exact dezelfde zwarte doos.
>> Neem nu een moment, de video opnieuw te pauzeren,
en proberen en te definiëren voeg twee integers, dat de andere functie die we
sprak over een moment geleden.
Ook hier heb ik de functie gezet verklaring, en zo de puntkomma,
en een open accolade en een gesloten krullend
brace om aan te geven waar we zullen vullen de inhoud van de add twee gehele getallen,
zodat we hier de specifieke gedrag in de zwarte doos.
Dus pauzeren van de video.
En neem zoveel tijd als je nodig hebt om te proberen en te bepalen
een implementatie van voeg twee integers, zoals dat wanneer de functie voert een waarde,
het, in feite, ruil de som van de twee invoeren.
Dus net als het vorige voorbeeld, Er zijn verschillende manieren
dat je zou kunnen implementeren voeg twee integers.
Hier is een.
Hier in oranje heb ik net wat comments--
Ik heb net een aantal extra commentaar te geven
wat er gebeurt op elke regel code.
Dus ik een variabele declareert genaamd som van het type int.
Ik zeg bedrag komt overeen met een plus b.
Dat is waar we eigenlijk mee bezig zijn het werk toe te voegen a en b samen.
En ik som terug.
En dat is logisch, want som is een variabele van het type int.
En wat is het datatype dat dit functie vertelt me ​​dat het gaat om de productie?
Int.
Dus ik ben terug te keren bedrag, dat een integer variabele.
En dat is logisch gezien wat we hebben verklaard en onze functie gedefinieerd
Te doen.
>> Nu kunt u ook definiëren de functie deze manier
int som gelijk aan een plus B-- overslaan eerst step-- en dan terug bedrag.
Nu kun je ook geïmplementeerd het op deze manier,
die ik sterk niet aan te raden.
Dit is slecht één stijl ding en echt slecht ontwerp,
maar het doet in feite werken.
Als u deze code, die is int nemen toe te voegen slecht adder punt c, en gebruik het.
Het doet eigenlijk toe twee getallen met elkaar.
Het is een zeer slechte uitvoering van dit gedrag.
Maar het werkt.
Het is gewoon hier om te illustreren het punt dat we niet echt
schelen wat er gebeurt binnen de zwarte doos, zolang
omdat het de output die we verwachten.
Dit is een slecht ontworpen zwarte doos.
Maar aan het eind van de dag, het doet nog steeds de output van de som van een plus b.
Prima.
Dus hebben we functies verklaard.
En we hebben gedefinieerde functie.
Dus dat is echt goed.
Laten we nu eens beginnen om de functies te gebruiken dat we hebben verklaard en we hebben gedefinieerd.
Om een ​​function-- het is eigenlijk noemen vrij easy-- alles wat je hoeft te doen
is pas het passend argumenten, argumenten van het type data
dat het verwacht, en dan is de return toewijzen
waarde van die functie en dit-- excuus mij--
wijs de return waarde van die functie iets van het juiste type.
>> Dus laten we eens een kijkje op Deze in de praktijk in een bestand
riep adder 1 punt c, dat Ik heb in mijn CS50 IDE.
Dus hier is adder 1 punt c.
Aan het begin zie je ik heb mijn omvat, pond omvatten,
standaard IO en CS50 dot h.
En dan heb ik mijn functie verklaring.
Dit is waar ik ben vertelt de compiler ik ben
zal schrijven een functie genaamd voeg twee integers.
Het gaat om de productie van een integer variabele.
Dat is wat dit deel is hier.
En dan heb ik twee ingangen om het een en b elk een geheel getal.
Binnenkant van de belangrijkste, vraag ik de gebruiker ingang door te zeggen, geef me een integer.
En ze wordt gevraagd om te vergeten int, die een functie
is bij de CS50 bibliotheek.
En dat wordt opgeslagen in x, een integer variabele.
>> Ze dan vragen wij voor een integer.
We krijgen nog een integer en op te slaan die in y.
En dan, hier op lijn 28, is waar we onze functie-oproep.
We zeggen, int z gelijken voeg 2 ints x komma y.
Zie je waarom dit zinvol?
x een integer type variabele en y een integer variabele.
Dus dat is goed.
Die zinvol met wat onze functie verklaring over de lijn 17 eruit ziet.
De komma's gescheiden ingang lijst verwacht twee gehele getallen a en b.
In dat geval kunnen we noemen ze wat we willen.
Zij verwacht slechts twee getallen.
En x een geheel getal is en y een geheel getal is.
Dat werkt.
>> En we weten dat de functie gaat output een integers ook.
En zo zijn we het opslaan van de uitgang van de functie,
voeg twee ints, in een integer variabele, die we bellen z.
En dan kunnen we zeggen, de som van i procent en het percentage i procent i.
respectievelijk x, y en z vullen die percent i's.
Wat de definitie van voeg twee ints eruit?
Het is vrij eenvoudig.
Het is een van degenen die we zag net een tweede geleden,
int som gelijk aan een plus b return som.
Werkt dit?
Laten we sla het bestand op.
En dan naar beneden hier op mijn terminal Ik ga adder 1 te maken,
en wis ik mijn scherm.
Ik ga om te vergroten, omdat ik weet het is een beetje moeilijk te zien.
>> Dus we dit programma als adder 1 compileren.
Dus we kunnen dot slash adder 1 doen.
Geef me een integer, 10.
Geef me nog een integer, 20.
De som van 10 en 20 is 30.
Zodat we een succesvolle functie oproep.
U kunt de functie opnieuw uit te voeren, negatief 10, 17 som van negatieve 10 en 17 is 7.
Deze functie werkt.
Het heeft het gedrag dat wij verwachten dat het.
En dus hebben we een succesvolle gemaakt functie, definitie, verklaring,
en een succesvolle functie-oproep.
Paar diversen punten over functies
voordat we sluiten dit hoofdstuk.
Herinneren van onze bespreking van data types,
eerder, dat functioneert kan soms geen ingangen nemen.
Als dat het geval is, hebben we verklaren de functie
als het hebben van een leegte lijst met argumenten.
Herinnert u zich wat de meest voorkomende functie
we tot nu toe gezien dat neemt een leegte lijst met argumenten is?
Het is de belangrijkste.
Ook herinneren dat de functie soms eigenlijk niet over een uitgang.
In dat geval, verklaren wij de functie als het hebben van een soort leegte return.
Laten we sluiten dit hoofdstuk door aanpakken van een praktijk probleem.
>> Dus hier is de aangelegd probleem.
Ik wil dat je een functie schrijven genoemd geldige driehoek.
Wat deze functie moet doen is neem drie reële getallen
dat vertegenwoordigen de lengten van de drie zijden van een driehoek als parameters,
of zijn argumenten, of zijn inputs-- andere set van synoniemen
die u kunt tegenkomen.
Deze functie moet ofwel uitgang waar of onwaar
naargelang deze drie lengtes zijn in staat om een ​​driehoek.
Herinnert u zich het soort gegevens dat we gebruikt om aan te geven waar of onwaar?
Nu hoe doe je dit uit te voeren?
Nou weet dat er een paar van de regels met betrekking tot driehoeken
die eigenlijk pas kan komen.
Een driehoek kan alleen kanten met positieve lengte.
Dat is logisch.
Je bent waarschijnlijk zeggen, duh.
Het andere ding om op te merken echter dat de som
van de lengte van elke twee zijden van de driehoek
moet groter zijn dan de lengte van de derde zijde.
Dat is eigenlijk waar.
Je kunt niet een driehoek van zijden 1, 2 en 4, bijvoorbeeld omdat 1 plus 2
niet groter is dan 4.
Dus dat zijn de regels die bepalen of de drie
ingangen denkbaar een driehoek.
Dus neem een ​​paar minuten en te verklaren en vervolgens te definiëren
Deze functie genaamd geldig driehoek, zodat het eigenlijk
heeft de hier genoemde gedrag.
>> Het zal de uitgang waar als de drie zijden in staat omvattende een driehoek,
en anders false Klaar om te zien hoe je deed?
Hier is een implementatie geldige driehoek.
Het is niet de enige.
Yours kan enigszins variëren.
Maar dit doet in feite hebben het gedrag dat we verwachten.
Wij verklaren onze functie op de top, bool geldig driehoek
zweven x float y float z.
Dus nogmaals, deze functie duurt drie reële getallen
als zijn argumenten, drijvende puntenwaarde variabelen,
en voert een waar of onwaar waarde, die een Booleaanse, recall.
Dus dat is de reden waarom de return type is Bool.
Dan is de functie te definiëren we.
Het eerste wat we doen is controleren om er zeker dat alle kanten positief.
Als x kleiner is dan of gelijk is aan 0, of wanneer y gelijk is aan 0,
of wanneer z kleiner is dan of gelijk aan 0, die onmogelijk een driehoek.
Ze hebben geen positieve kanten.
En zo kunnen we terugkeren vals in die situatie.
Vervolgens controleren we om ervoor te zorgen dat elk paar ingangen
groter dan de derde.
>> Dus als x plus y minder dan of gelijk aan z,
of indien x plus z kleiner dan of gelijk aan y,
of y plus z kleiner is dan of gelijk aan x, die ook geen geldig driehoek.
Dus we terugkeren vals.
Ervan uitgaande dat we allebei van de controles gepasseerd hoewel, dan kunnen we echt terug.
Omdat deze drie zijden in staat returning--
het maken van een geldige driehoek.
En dat is het.
Je hebt nu verklaard en gedefinieerd.
En u kunt nu in staat zijn om gebruiken en bel deze functie.
Geweldig werk.
Ik ben Doug Lloyd.
Dit is CS50.