Hallo en welkom.
In deze lezing wil ik praten over het retourneren van gegevens uit functies.
Tot nu toe weten we wat een functie is dat we weten waarom het nuttig is, we
weten hoe we functies moeten definiëren, we weet hoe u gegevens aan functies moet doorgeven.
Nu willen we het hebben over hoe we kan gegevens van functies retourneren,
wat ook erg handig is.
In ons eerdere voorbeeld, toen we vermenigvuldig twee getallen, een vermenigvuldigingsfunctie gaf
de resultaten weer van de berekening op de terminal.
Vergeet niet dat we dat hadden printf verklaring daarin.
We hadden ook een voorbeeld waarbij we waren vroeger slechts een eenvoudige functie.
We hebben zojuist gegevens uitgeprint binnen de functie.
We wilden aardig zijn in plaats van breng het naar buiten
omdat het eigenlijk meer dan één ding doet.
Het heeft het eigenlijk uitgeprint, de gegevens zijn geretourneerd en het
heeft de gegevens in de hoofdfunctie afgedrukt.
Misschien wil je niet altijd de resultaten uw berekeningen weergegeven.
De functie wordt meer flexibel, meer generiek, waardoor het op
zijn beurt kan worden gebruikt meer als u gegevens kunt retourneren.
Dus functies kunnen gegevens retourneren met behulp van specifieke syntaxis in c.
Dit zouden we moeten kennen een beetje, want
onthoud onze hoofdfunctie op de zeer einde geven we in veel van de voorbeelden
nogal wat gegevens terug.
We zijn hier dus een beetje aan blootgesteld.
We hebben het gewoon niet echt begrepen wat het betekent.
Laten we nog eens kijken naar de algemene vorm van een functie.
Onthoud, deze functiekop.
We hadden een retourtype dat was het woord dat voor het eerst werd gedefinieerd.
En toen hadden we de naam, en toen we hadden de parameters gescheiden
door komma's tussen haakjes.
We kennen de naam en de parameters.
Dat eerste is het retourtype.
Het retourtype specificeert: het gegevenstype van de waarde die door de
functie wordt geretourneerd.
Functies kunnen alle soorten gegevens retourneren.
Je hoeft alleen maar de compiler te laten weten wat voor soort gegevens u retourneert als.
Het is een int, een float, een double wat het ook is, je moet dat
specificeren in je functiekop.
Het retourtype.
Het retourtype dat we hier zagen, en u kunt dat type waarde specificeren dat door een
functie moet worden geretourneerd zolang het een juridisch type is in c.
Ik noemde de belangrijkste, verdubbelen, zweven enzovoort.
Maar je kunt ook terug opsommingen en verwijzingen.
We hebben geen aanwijzingen besproken, maar het maakt het heel, heel flexibel wanneer
je pointers kunt retourneren.
Het retourtype kan ook vermijden type.
Je ziet vaak dat dit zoekwoord ongeldig is.
We begrijpen nu wat het betekent.
Void betekent dat er geen gegevens zijn gaat worden teruggestuurd.
Als je leegte ziet voor de naam van de functie, retourneert
u geen gegevens.
Als je leegte in de parameters ziet lijst, u geeft geen gegevens door.
Void is slechts een algemeen zoekwoord dat voor retourtypen en voor parameters merk je ook dat je void . kunt gebruiken ook als
een aanwijzer, maar daar komen we op terug als we
daar aan toe zijn.
Maar leegte is een manier om niets te zeggen.
En de reden die je opneemt? nietig in tegenstelling tot
gewoon niets opnemen omdat het maakt het programma leesbaarder.
Eigenlijk wanneer u gegevens doorgeeft aan een functie en je hebt
geen geen gegevens die worden doorgegeven, je kunt hebben het zijn gewoon lege haakjes.
Het is gemakkelijk te lezen als je hebt leegte daar.
Hetzelfde met een retourtype behalve de retourtype moet je void hebben.
Je kunt het niet gewoon leeg hebben.
Nietig betekent dat er geen gegevens zijn gaat worden teruggestuurd.
De retourverklaring.
We hebben het gehad over hoe je dat kunt identificeren welke gegevens zullen worden geretourneerd, maar
hoe? u geeft de gegevens daadwerkelijk terug.
Binnen het lichaam van de functie, je moet u een verklaring hebben waarop u kunt
zeggen wat u gaat retourneren.
Want onthoud het lichaam van een functie kan veel gegevens bevatten.
Het kan lokale variabelen hebben, het kan alles hebben waarvan je weet dat de
functie een specifieke berekening zou kunnen doen, misschien meerdere berekeningen doen, wat
wil je retourneren.
Gelukkig is er deze verklaring met het trefwoord return.
Als u het rendement opgeeft: zonder variabele naam na of uitdrukking, dat
betekent dat je gewoon de functie verlaten.
Het is vergelijkbaar met een onderbreking in een lus.
Je komt net terug uit de functie.
En u kunt dit in functies die als ongeldig zijn gedefinieerd.
Het maakt duidelijk wanneer je verlaat de functie.
Je zou eigenlijk alleen moeten hebben de return op één
plek onderaan de functie.
Daar komen we later op terug, maar jij kan het nergens in een functie hebben.
Als je het ergens ziet in een functie, betekent dit dat je
uit die functie springt.
De reden waarom het goed is om te hebben onderaan staat dat het heel duidelijk
is wanneer je de functie verlaat.
Als je meerdere retouren hebt zelfs als u tijdens uw hele functie gegevens
retourneert, is het moeilijk te zeggen wanneer je terugkeert.
Dus wat ik graag doe in mijn functies is variabelen maken en maar
één keer onderaan terugkeren.
Als ik iets moet retourneren in een functie of ik bedoel in een specifieke if-instructie in een functie
of iets Ik zal de variabele instellen en
deze vervolgens onderaan retourneren.
Dus als je terugkeer hebt en jij heb er niets achter,
dat betekent gewoon dat je de . verlaat functie zonder dat er gegevens worden geretourneerd.
Dit wordt echt niet zo veel gebruikt.
Je gebruikt het alleen in de leegte functie, retourneert geen waarde.
De meer algemene vorm van de return-instructie retourneert een
variabele of een expressie.
X plus y of x teruggeven.
Deze vorm van de retourverklaring heeft te gebruiken met het retourtype dat is
opgegeven in de functiekop.
Als je een int retourneert, wat die variabele of uitdrukking die je retourneert
ook een int moet zijn.
Het moet evalueren tot een int, als je een int.
Als je nu dubbel draait, het moet een waarde hebben om te verdubbelen.
Onthoud dat je er veel kunt hebben verschillende soorten gegevens geretourneerd.
De waarde die wordt geretourneerd naar het aanroepende
programma is de waarde die ontstaat wanneer de expressie wordt zo geëvalueerd.
Als je x plus y hebt, keert het terug het resultaat van die uitdrukking en het moet
van hetzelfde type zijn als de functieverklaring zoals ik al zei.
Een functie met statements in de
functie body maar retourneert geen waarde moet de . hebben retourneer type als ongeldig, moet.
Dat kun je niet hebben.
Als je dat niet hebt en je bent geen
gegevens retourneert, krijgt u een foutmelding.
Wanneer u het programma compileert en het bevat een functie met
een ongeldig retourtype dat probeert retourneer een waardecompilerfout.
Nietig betekent geen retourgegevens, niet doen retourneer een variabele een uitdrukking.
Als een functie geen leegte heeft retourtype en
het heeft een geldig retourtype, je krijgt een foutmelding als de compiler
een ander type probeert te retourneren dan een opgegeven of als ze
net zijn teruggekomen met niets erachter.
Let hier dus goed op.
Die trefwoorden aan het begin van de functionele verklaring zijn belangrijk.
Het heeft direct invloed op de uitvoering van de functie en het compileren zal je vertellen of je het verkloot op en je stuurt
niet de juiste gegevens terug of als je niets
terugstuurt gegevens of als u gegevens retourneert terwijl het niet de bedoeling
is dat u gegevens retourneert.
Als de uitdrukking resulteert in een waarde dat is een ander
type dan het retourtype in de functie header, zal c proberen het te converteren.
De compiler zal proberen om te zetten als het kan.
Dus bijvoorbeeld als je terugkeert een float en je uitdrukking is I plus x met twee ints,
het gaat om het gewoon om te zetten in een vlotter.
Als je een int en . retourneert je
hebt een uitdrukking die float-berekening uitvoert, het zal het omzetten in een het.
Daarin ga je data verliezen geval, maar het zal conversie doen.
Het is niet altijd mogelijk om de conversie te doen.
In gevallen waarin het niet mogelijk is, je krijgt een fout die wordt
geproduceerd door de compiler.
Als u een int . probeert te retourneren wanneer je
een string moet retourneren of wanneer je het probeert om het terug te
geven wanneer je verondersteld wordt een opsomming terug te geven, het is ga de compiler klagen.
Je kunt er ook meer dan één hebben return statement een functie,
ik noemde dit kort en waarom wil je het niet doen.
Maar je kunt het.
U kunt meerdere keren retourneren doorheen de functie.
Het maakt de code alleen maar moeilijker om te volg
want je springt overal uit de functie.
Wanneer je terugkomt en je hebt meerdere retourwaarden, zorg er gewoon
voor dat je nog een keer een functie hebt dat
is iets teruggeven, je hebt een uitdrukking of een waarde van dat type of het kan worden geconverteerd.
Nu we het er toch over hebben gehad het doorgeven van gegevens en het
retourneren van gegevens, we weten hoe we een functie moeten aanroepen, maar ik wil
nog een paar andere dingen zeggen over aanroeping.
Je roept een functie aan door gewoon te gebruiken de functienaam gevolgd door
de argumenten die u doorgeeft die zijn tussen haakjes weten we
dat, voor zover weten we maar ik wil je het formeel aangeven, zo kun
je een functie aanroepen.
Wanneer u de functie oproept, wordt de waarden
van de argumenten die u tussen de haakjes opgeeft worden toegewezen aan
parameters binnen de functie.
De parameters zijn representatief variabelen met een gegevenstype.
U kunt dan die variabele gebruiken elke kant in het functielichaam.
Wanneer de functie wordt afgesloten of uitgevoerd bepaalde code, zal het de opgegeven waarden als argumenten gebruiken,
zoals ik al zei.
De argumenten die u opgeeft wanneer u aanroep van een functie moet
overeenkomen in typenummer en volgorde wanneer de parameters in de functiekop.
Bestelling is ook van belang, ik niet benadruk dat, maar als
er int x double y staat, moet je eerst pas in de int dan de dubbele.
Je kunt niet passen in de double en int.
De bestelling is heel, heel specifiek.
Zorg er dus voor dat u de gegevens doorgeeft als: een argument
wanneer u de functie op dezelfde manier aanroept als de functie wordt gedeclareerd in de functiekop
in de parameterlijst, passeren de juiste soorten is dat ook.
Een functie aanroepen en toewijzen van de geretourneerde gegevens.
Als een functie gegevens retourneert, is de functie kan die gegevens toewijzen door de operator is
gelijk aan en daarna te gebruiken het rendement ook of u kunt het desgewenst in een
lokale variabele opslaan.
Het werkt ook met een uitdrukking.
Dus je kunt zeggen return x plus y, je kunt return x zeggen, je kunt
zeggen return een constante.
Dit voorbeeld hier is na jou roep de oproep op wanneer u de geretourneerde
gegevens wilt toewijzen.
Dus je kunt zeggen dat int x gelijk is aan my functieaanroep, wat die functie
ook teruggeeft, wordt toegewezen aan x.
En als mijn functieaanroep terugkomt x plus y, het resultaat van x plus y
wordt toegewezen aan x.
U kunt dus de gegevens toewijzen die geretourneerd van een
functieaanroep door alleen een variabele op de . te hebben linkerkant van
de gelijken en de functie-aanroep op de rechterkant van de gelijken.
De aanroepfunctie heeft geen om de waarde te herkennen of te verwerken die wordt
geretourneerd door een aangeroepen functie.
Je hoeft niet te hebben die opdracht daar.
Als een functie gegevens retourneert en je geeft niet om die gegevens, je hoeft helemaal
geen gelijken te hebben, je kunt de functie gewoon aanroepen.
Het zou niet echt logisch zijn, want als het gegevens retourneert, betekent dit
dat u waarschijnlijk moet kijken naar het, maar je hoeft het niet te doen.
De compiler gaat niet klagen als je gewoon een
functie aanroept en de gegevens niet verwerkt.
Het is aan jou hoe je de gegevens wilt gebruiken die
worden geretourneerd door functieaanroepen.
Hier is een voorbeeld van het aanroepen van een functie en ook het retourneren van gegevens
van een functie.
Vermenigvuldig in dit voorbeeld twee getallen.
Dit was net als het voorbeeld dat we eerder had, maar het
vorige voorbeeld heeft geen gegevens geretourneerd.
In het vorige voorbeeld werd uitvoer weergegeven.
In dit voorbeeld zijn we geen output weergeven.
We sturen de gegevens terug en dan geven we de
uitvoer weer in de hoofdfunctie.
Hier onze vermenigvuldig twee getallen neemt twee gehele getallen als parameters.
We vermenigvuldigen die twee gehele getallen.
En dan in plaats van dit af te drukken bedrag of de waarde, we gebruiken het trefwoord return
en we zijn dan specificeren van een variabele met de naam resultaat en dan hebben we
de puntkomma om het te beëindigen.
Wanneer je dat return-trefwoord ziet in de body van de functie retourneert
u die gegevens.
En onthoud, dat kan heb dat meerdere plaatsen.
Maar je kunt het maar één laten retourneren waarde, kunt u niet meerdere waarden retourneren.
Dus als u het return-sleutelwoord in meerdere plaatsen, het moet in een
if-statement of lus staan omdat je springt er dan gelijk uit.
Als je een retour hebt gevolgd door nog een keer terug, het
geeft je een foutmelding omdat het zou zeggen dat je hebben in beide gevallen twee rendementen.
Je keert altijd terug naar resultaten, dat kun je niet doen.
Maar het return-trefwoord is belangrijk.
Je retourneert een variabele.
En dan zie je in het algemeen functie waaraan de gegevens worden toegewezen
waaraan wordt geretourneerd een andere lokale variabele genaamd resultaat.
Je zult merken dat we gebruik maken van dezelfde namen hier.
Dit heeft te maken met functie scope waar we
het in de volgende lezing over gaan hebben, local variabelen versus globale variabelen.
Alles wat je nodig hebt om op te letten in deze lezing is
het feit dat deze functie vermenigvuldigd is twee getallen retourneert gegevens.
Hoe u het retourneert, u retourneert het met behulp van het sleutelwoord return
gevolgd door de variabele van de uitdrukking.
Je merkt ook dat de vermenigvuldiging twee getallen specificeert het
retourtype bovenaan de functiekop.
Het retourneert een int.
We moeten dus een int.
Dat merk je ook als we toewijzen de gegevens in
de hoofdfunctie, we wijzen het toe aan int.
Het toewijzen van die zeer gemakkelijke we heb gewoon de is gelijk aan operator.
Als we niet om de gegevens gaven, zouden we zou gewoon twee getallen
vermenigvuldigen kunnen noemen en er dan niets mee doen.
Nadat we de gegevens hebben geretourneerd van de functie, we printen het
vervolgens uit met behulp van een printf-functie.
Dit maakt de functie meer samenhangend dat er gegevens voor nodig zijn.
We geven niet echt weer de resultaten binnen de functie.
Er zijn tijden dat we niet willen om de resultaten
weer te geven, willen we gewoon twee getallen vermenigvuldigen en dan misschien willen we het product verdelen.
Flexibiliteit bij het doorgeven van gegevens en gegevens die worden geretourneerd, is een groot probleem.
Dit is een eenvoudig voorbeeld.
Je gaat blootgesteld worden aan dit meer in onze volgende uitdaging.