Hallo, en welkom terug.
In deze lezing wil ik praten over het definiëren van functies in c.
Een functie definiëren.
We kennen het belang van functies.
Wij begrijpen de voordelen.
We zullen willen gebruiken functies in onze programma's.
Dus wanneer u een pro-functie maakt in c, moet je de functiekop specificeren
als de eerste regel van de definitie van de functie.
We gaan het hebben over definiëren een functie, en we gaan het
ook hebben over het implementeren van een functie.
Een functie implementeren is gewoon het oplossen van problemen,
het is gewoon gewone c-code.
Een functie definiëren is zeggen dat de functie bestaat.
Dus als je een functie definieert, wordt de het eerste wat je
doet is dat je die functiekop hebt en dan volg je dat met een accolade waarmee de
blokcode voor de functie begint.
Dus het is net als wanneer je een accolade
in een if-statement, net zoals wanneer je een accolade gebruikt in een for-lus, behalve dat de
accolade vereist is voor functies.
Er is geen manier om het te elimineren.
En het betekent altijd het begin van de code voor die functie.
Alles tussen de start en eindigende accolade is de code
voor de functie.
Het is waar je heen gaat om de taak uit te voeren.
Dus tussen de beugels zit genaamd de functie body en de eerste regel
van de functie wordt de functiekop genoemd.
De functiekop definieert de naam van de functie, de parameters
van de functie.
We gaan het hebben over parameters en argumenten in detail.
Maar op dit moment ben je gewoon moet weten dat er
iets is dat parameters wordt genoemd.
En de parameter gaat specificeren: het aantal en de soorten waarden
hoe u gegevens, parameters kunt doorgeven te maken hebben met het doorgeven van gegevens.
Het type voor de waarde dat de functie terugkeert.
We noemden dat functies we kunnen gegevens retourneren.
Dus in die functiekop, je krijgt de naam
van de functie, de gegevens die u kunt nemen kan worden geaccepteerd door de functie
en de gegevens dat wordt geretourneerd door de functie.
We gaan ons nu niet concentreren over de gegevens die kunnen worden doorgegeven of de gegevens die
worden geretourneerd, gaan we gewoon praten over het maken van een eenvoudige functie.
De functietekst bevat: gewoon gewone code, en die code wordt uitgevoerd
als je de functie aanroepen of aanroepen.
En het functielichaam zelf heeft toegang tot alle waarden die als
argumenten worden doorgegeven.
Dus de gegevens die u doorgeeft aan it, kunt u die gegevens
gebruiken in de hoofdtekst van de functie.
Hoe het eruit ziet is dit, de functiekop.
Functiekoptekst heeft het eerste woord.
En functiekop is a trefwoord dat het type gegevens vertegenwoordigt dat
wordt terug van de functie.
Het volgende sleutelwoord is er de naam van de functie.
En dan heb je een haakje links en dan heb je parameters gescheiden door komma's,
dat zijn de gegevens dat wordt doorgegeven aan de functie.
En dan heb je dat rechter haakjes
om de functiekop te beëindigen.
Dan heb je de accolade dat betekent het begin
van de functie-implementatie.
En je hebt een willekeurig aantal uitspraken om een taak uit te voeren.
Zoals ik al zei, wil je? laat je functies klein zijn.
Ze willen samenhangend zijn.
Ze willen niet zijn overal.
Ze willen een single hebben focus, doe iets specifieks.
Zoals ik al zei als je een functie hebt die invoer krijgt, leest invoer.
Het drukt geen uitvoer af.
Het sorteert niet of doet niets anders.
Als je een functie hebt met de naam sorteren, het sorteert de gegevens.
Het krijgt geen invoer.
Functies moeten zijn: samenhangend en klein.
Het is veel gemakkelijker om die te debuggen functies, dus maak ze samenhangend.
En dan heb je gelijk accolade, die
de functie-implementatie beëindigt.
Dat is wat een functie ziet eruit als in c.
Laten we ons nu concentreren op de functie namen, en we zullen het
later hebben over de parameters en retourtypen.
De eerste regel van de functie opnieuw definitie vertelt de compiler in volgorde van
links naar rechts drie dingen over de functie, zoals ik al zei.
Het type van de waarde retourneert, de naam van de functie en
vervolgens alle benodigde gegevens.
Dit is gewoon om samen te vatten, dat is belangrijk.
Wat functienamen betreft, wilt u: om betekenisvolle functienamen te kiezen.
Het is net zo belangrijk als kiezen betekenisvolle namen van variabelen.
Het heeft grote invloed op de leesbaarheid van het programma,
dus noem geen functies x of y.
Geef de functie een naam over wat het gaat doen.
Als het er twee zijn nummers, noem maar op.
Als het twee aftrekt getallen, noem het aftrekken.
In dit voorbeeld is hier: onze eenvoudige functie.
Maak je geen zorgen over de leegte, maak je alleen zorgen over de naam hier.
We hebben een functie benoemde afdrukbericht.
En dan zien we die accolade wat
het begin van de functie betekent, en dan we hebben wat uitvoering.
En deze implementatie doet niets anders dan het
weergeven van een string, een tekst.
En dan hebben we dat rechter accolade.
Dit is dus een heel eenvoudige functie doet niet veel, het geeft output weer.
In dit voorbeeld voor de print bericht, de eerste
regel van het afdrukbericht vertelt de compiler dat de functie geen waarde retourneert.
Dat is het sleutelwoord leegte.
Nogmaals, u hoeft zich niet te concentreren op dat, maar dat is wat dat doet.
De volgende is de naam.
En dan na de naam is argumenten, worden ze parameters genoemd.
En we gebruiken het trefwoord void opnieuw als we geen gegevens doorgeven.
Het statement in de functie lichaam mag ontbreken, maar de beugels
moeten altijd aanwezig zijn.
Je hoeft er dus eigenlijk geen te hebben implementatie, maar je moet de accolades hebben
voor een functie om daar te zijn.
Als er geen verklaringen in zijn de hoofdtekst van een functie,
moet het retourtype ongeldig zijn.
En nogmaals, we zullen ons hier later op concentreren en de functie zal niets doen
omdat je geen implementatie hebt.
Als u een functie definieert met een leeg lichaam, het kan nog steeds
nuttig zijn, ook al is het niets bereiken.
Dat doe je meestal tijdens de testfase van een zeer groot programma.
En wat je hiermee kunt doen? is dat je het programma alleen
met bepaalde functies kunt uitvoeren? iets doen, helpt u beter te
testen, helpt u fouten te isoleren.
Je zou zelfs implementatie kunnen hebben in de test in
de functietekst, maar becommentarieer het gewoon.
En dan kun je dit doen verdeel en heers aanpak.
Naarmate je meer en meer test en meer, u kunt dan beginnen met het invoeren
van de implementatie in de functie-instanties.
Het is een stap-voor-stap proces van werken.
Je werkt constant in het klein chunks, code toevoegen, die code testen en dan doorgaan naar de
volgende stap en dan zal uiteindelijk de hele implementatie
worden voltooid en alle functies worden geïmplementeerd.
Er is dus een use case voor: met een functie-body
die geen code heeft of is becommentarieerd.
Functies benoemen.
De naam van een functie kan elke wettelijke naam zijn.
Net als wanneer je bent Als u een variabele een naam
geeft, kunt u geen gereserveerde woorden gebruiken.
Dit zijn dus sleutelwoorden in de taal zoals enter doubles
omdat ze gegevenstypen vertegenwoordigen.
Sizeof is een operator.
Je wilt in staat zijn om het te gebruiken voor of als.
Je kunt er ook geen twee hebben functies met dezelfde naam.
En dit wordt ook wel genoemd als functie-overbelasting, soort van.
Maar je kunt geen twee functies hebben met dezelfde naam wordt overbelasting niet
ondersteund in c.
Ten slotte kunt u hetzelfde hebben name als een functie die in
de standaard bibliotheekfunctie zit.
Technisch gezien, als u niet opneemt die bibliotheek een headerbestand bevat, kunt u
het misschien hebben.
Maar als je ooit echt wilde gebruiken die bibliotheekfunctie, zou de compiler
klagen en zeggen dat je hebt twee functies met dezelfde naam.
Dus noem je functies niet de hetzelfde als standaard bibliotheekfuncties.
Een wettelijke naam is hetzelfde als een variabele, een reeks letters
en cijfers om te beginnen.
Het eerste teken moet een letter zijn en de letter kan een onderstrepingsteken zijn.
U kunt functies niet starten met cijfers of andere
vreemde tekens.
De naam die je kiest moet betekenisvol en relevant zijn voor
wat de functie doet.
Ik zei dit al, ik herhaal het voor de nadruk, betekenisvolle namen
zijn erg belangrijk.
Je definieert vaak functie namen en ook namen van variabelen die uit
meer dan één woord bestaan.
Dus nu wil ik een beetje praten beetje over alleen coderingsstijl.
Je hebt het vast al gemerkt toen ik... schreef mijn code dat ik camel case gebruik.
Er zijn drie verschillende manieren: u kunt de namen van uw
variabelen en functies schrijven.
U kunt elk van de woorden scheiden in een functienaam met
een onderstreept teken is het één benadering.
U kunt de eerste letter in hoofdletters zetten van elk woord of
u kunt woorden na het eerste woord met een hoofdletter schrijven, en jullie tokkelen nog steeds samen.
Onthoud, dat kan niet tussenruimtes hebben.
Dit is slechts een benadering voor naamgeving omdat het
belangrijk is dat je een bepaalde conventie volgt zodat het makkelijker te lezen is.
Even een lang woord met vijf verschillende woorden.
Dus als je een functie had die zegt: controleer op geldige invoer, u zou die niet
allemaal in kleine letters willen hebben.
Het zou heel moeilijk zijn om te lezen en identificeren waar de woorden waren.
Dus camel case is een manier om identificeer waar de woorden in veel woorden
staan en het is gemakkelijk te zien wat die functie doet.
Een onderstrepingsteken is een andere manier om woorden te scheiden.
En de eerste letter van met een hoofdletter elk woord is een andere manier om te scheiden.
Het is belangrijk om te kunnen scheid de woorden in een functie om
het leesbaarder te maken.
Ik gebruik meestal camel case.
En wanneer u een van deze gebruikt conventies, je wilt het voor
alles gebruiken, je wilt het gebruiken het voor het benoemen van variabelen, je
wilt het gebruiken voor je functienamen.
Meestal volg je dit gewoon gemeenschappelijke codeerconventie, het
maakt dingen leesbaarder.
Functie prototypes.
We hebben het gehad over het definiëren van een functie.
Hoe zit het met het declareren van een functie.
Je zou kunnen zeggen waarom moet je? een functie declareren, declareert u het
niet wanneer u het definieert.
Maar er is ook een concept van het declareren van een functie.
En het is nodig als je wilt om de functie te gebruiken voordat deze wordt
geïmplementeerd, voordat deze wordt gedefinieerd.
Dus een functie-prototype is a statement dat een functie definieert.
Het vertelt de compiler in wezen: alle details van de functie.
Het definieert de naam, het retourtype en het type van elk van zijn parameters.
Het ziet er dus uit als een functiekop.
Het biedt alle externe specificaties van de functie,
heb je waarschijnlijk ook wel eens van gehoord de term signatuur,
functiesignatuur dat is het.
Het specificeert de geretourneerde gegevens, de gegevens die nodig
zijn en alles over de functie zelf.
U wilt een functie-prototype schrijven op dezelfde manier als waarop u de functiekop schrijft,
het enige verschil is dat: je zet een puntkomma aan het einde.
En dit is gewoon functie declareren.
Dit zegt dat de functie bestaat.
Een functie-prototype maakt: de compiler om de juiste instructies te
genereren bij elke punt waar u de functie oproept.
Het controleert ook of u de correct functioneren in elke aanroep.
De reden dat u functie biedt: headers is zodat u de functie kunt aanroepen zonder een
waarschuwing of een functiedeclaratie zonder dat het wordt geïmplementeerd, dus het is eigenlijk gewoon de volgorde van je
code en ik zal je hier zo meteen
een voorbeeld van geven.
Wanneer u een standaardkoptekst opneemt bestand in een programma,
voegt het headerbestand het functieprototype toe.
Functie-prototypes gaan meestal in header-bestanden als u ze in veel verschillende
bronbestanden wilt hergebruiken.
Als je ze maar in één keer gebruikt bronbestand, u kunt ze
gewoon bovenaan in het bronbestand plaatsen.
Maar omdat we de printf . gebruiken functie die in veel
verschillende bronbestanden kan worden gebruikt, die header functie wordt gedefinieerd in de
kop of die functiedeclaratie wordt gedefinieerd in de kop.
En in dit geval stdio. H.
Dus ze verschijnen meestal in bronbestanden als alleen dat bronbestand
die functie gebruikt.
Anders zet je ze in een header-bestand als
ze worden hergebruikt door veel bronbestanden.
Hiermee kunnen alle functies in de bestand om een van die functies aan te
roepen die zijn gedefinieerd, ongeacht waar je hebt de implementatie geplaatst.
Als u de implementatie plaatst van een functie, nadat je het hebt aangeroepen, gaat c
klagen en zeggen: dat hij er niets van weet.
Want als je compileert, je compileert regel voor regel.
Als u de aangifte plaatst bij bovenaan, dan kunt u de functie
aanroepen voordat deze is gedefinieerd, voordat het wordt geïmplementeerd.
Parameternamen hoeven niet de . te zijn hetzelfde gebruikt in de functiedefinitie.
Je kunt verschillende namen hebben.
Als ik namen zeg, zijn dat de identificatiegegevens van de gegevens.
U kunt de naam van de parameters in het functie-prototype.
Je moet nog steeds dezelfde gegevens hebben typen, maar u kunt de namen wijzigen.
Het is altijd een goede gewoonte om functiedeclaraties
opnemen voor alle functies in uw programma bovenaan het bestand.
Het houdt je programma consistenter aan het ontwerp en het voorkomt
fouten in elk stadium als u die functie ooit wilt aanroepen
voordat u deze implementeert.
Hier is een voorbeeld van enkele functie-prototypes.
Helemaal bovenaan de bestand, we hebben onze include.
En dan hebben we wat functies die we hebben gedeclareerd,
gemiddelde, som en gegevens ophalen.
Je merkt dat het er gewoon uitziet zoals een functiekop.
Het heeft het retourtype, heeft de parameters die zijn gedefinieerd
in de functie, maar het heeft een puntkomma aan het einde.
Er is geen implementatie voor deze functies.
Je vertelt het gewoon aan de compiler dit is de functie die bestaat en
dit is hoe het is gedefinieerd.
Wat dit je in staat stelt om te doen is nu in je hoofdfunctie zou je
het gemiddelde kunnen noemen, je zou kunnen noemen de som, je zou kunnen bellen om gegevens te krijgen.
En de daadwerkelijke implementaties kunnen wees beneden waar je ze belt.
Als je de functie niet had headers hier, toen
je ze in het hoofd probeerde te bellen, als ze waren gedefinieerd onder de hoofdroutine, zou
u fouten of waarschuwingen krijgen.
Dus laten we eens kijken op dat in codeblokken.
Hier hebben we onze gebruikelijke hoofdroutine.
Laten we nu zeggen dat we willen om een functie te creëren of we willen een
functie aanroepen.
We gaan een beroep doen op a functie genaamd add en er zijn
geen parameters voor nodig.
We noemen het in onze hoofdfunctie op regel 7.
Zouden gaan implementeer het op regel 10.
We gaan zeggen ongeldig toevoegen en we gaan niet eens iets doen.
We houden het gewoon leeg.
Als we dit gaan compileren, wat? je zult merken dat deze compiler alleen
een waarschuwing geeft.
Er staat add heeft een impliciete verklaring.
Je kunt van die waarschuwing afkomen door een functiedeclaratie te gebruiken.
U kunt de functie declareren: naar boven in feite de compiler vertellen dat je gaat
gebruik het ergens, maar je weet niet
waar de implementatie is.
Dus wat je kunt doen, is dat je het kunt zeg void optellen hier
en voeg gewoon de puntkomma toe.
Nu zal het daar vanaf komen waarschuwing en sommige compiles zullen u zelfs
een foutmelding geven.
Als ik het nu compileer, heb ik geen waarschuwingen en geen fouten.
Dus dat is wat een functie aangifte doet.
Het stelt je in staat om de functie overal.
Als je de functie niet had verklaring bovenaan en je had de implementatie hierboven
waar je aan het aanroepen was, dan zie je de fout ook niet omdat
de compiler gaat weten over de functie voordat hij deze
daadwerkelijk probeert aan te roepen.
Dus als wij dit bouwen, ben jij ook ga kijken of er geen fout is.
Nu zei ik dat je meestal al uw functies bovenaan wilt
declareren, gewoon voor een goede gewoonte en ik denk dat je dat wel moet doen.
Dus blijf dat doen.
Maar als je daar uit komt gewoonte, je moet ofwel je
functies declareren voordat je ze aanroept of je moet
functie-prototypes aanleveren omdat je dat niet wilt waarschuwingen of fouten in uw programma.
Zo kun je een definiëren functie, en dit is hoe
u functie-prototypes kunt gebruiken.
In de volgende lezing gaan we
het hebben over parameters.
Hoe u gegevens aan een functie kunt doorgeven.
Dank u.