Hallo en welkom.
We starten een nieuwe rubriek.
Onze sectie is gebaseerd op functies.
Dus we gaan het hebben over een aantal eerst de basis van functies.
Een functie is een op zichzelf staand eenheid van programmacode
ontworpen om een bepaalde taak te volbrengen, dat is een definitie op hoog niveau.
Functie zal in principe zijn: iets dat u kunt aanroepen en
waarmee u duplicatie van code kunt verminderen.
Maar wat het doet is het is op
zichzelf staand in de code zelf, en het heeft slechts enkele taken dat het gaat lukken.
Syntaxisregels gaan naar: de structuur van een functie definiëren
en hoe deze kan worden gebruikt.
Dus afhankelijk van welke programmering taal die u gebruikt,
kunnen functies anders zijn gedefinieerd.
Voor c gaan we praten over specifieke regels voor c.
De meeste programmeertalen ondersteunen dit concept van een functie, en ik zal je de
voordelen vertellen en waarom ze worden ondersteund.
Een functie in c is hetzelfde als subroutines of procedures
in andere programmeertalen.
Zo vaak hoor je deze termen subroutines en procedures, hetzelfde
als een functie.
Op zichzelf staande eenheid die uitvoert een code die u kunt bellen.
Sommige functies veroorzaken een actie plaatsvinden.
Dus we kennen er een paar functioneert tot op dit punt.
We hebben de printf bestudeerd functie die de uitvoer
op uw scherm weergeeft die een actie, doet iets voor je.
En dan resultaat hebben we ook gekeken bij de scanf-functie die invoer
van het toetsenbord nodig heeft.
Nogmaals, het doet een andere actie.
Andere functies wel kan eigenlijk gewoon een waarde vinden
voor een programma om te gebruiken.
Dus bijvoorbeeld als we strijkers bestuderen en tekenarrays, we gaan kijken
naar functies voor string manipuleren en dingen veranderen.
Er is een functie in het bijzonder roerlengte genoemd en dat zal een
programmeur vertellen hoe lang een bepaalde string is.
Het voert geen actie uit, het is geeft u alleen informatie terug.
Dus functies gaan presteren taken afhankelijk van de taak wat u
moet bereiken in uw programma, het
zal ofwel een actie veroorzaken of het gaat een wijzigen programmeerwaarde of retourneer een waarde of vertel
u wat statusinformatie.
Voordelen van functies.
We gaan functies gebruiken omdat ze een heleboel voordelen hebben.
Functies zorgen voor de verdeel en heers strategie.
Dus als je zou opschrijven en ga een middelgroot programma
of een groot programma schrijven, het gaat heel, heel moeilijk te onderhouden zijn.
Het zal moeilijk zijn om te testen, debug en vind en repareer eventuele fouten als je een
enkele grote functie hebt.
Dus afbreken en dit doen het verdelen van de veroveringsstrategie
zal het een stuk gemakkelijker maken om vind en repareer bugs in uw code.
En kun je je een enkel c-programma voorstellen? dat alles wat ik had de hoofdfunctie was en
dat er 5000 regels in zaten.
We zouden geen idee hebben hoe om dat probleem aan te pakken.
Het is echt een slechte organisatie.
Je hebt geen samenhang en je duikt er gewoon in om een probleem
op te lossen.
Dus we gaan functies gebruiken.
Verdeel en heers betekent eigenlijk: dat taken kunnen worden onderverdeeld in
verschillende onafhankelijke subtaken.
Het vermindert de algehele complexiteit van de code.
U kunt afzonderlijke functies maken voor elke subtaak, en dan kun
je zelfs meer functies maken om te verdelen de subtaak in kleinere subtaken.
Elke keer dat u deze aanvullende functies, het vermindert de complexiteit.
Je doel zou moeten zijn wanneer je bent deze
functies maken en de verdeel en heers gebruiken strategie is om uw
functies zo samenhangend mogelijk te maken.
En wat dat betekent is ervoor zorgen elke functie voert slechts één taak uit, heb geen
functie doe 5 verschillende taken of 10 verschillende taken.
Als u een functie schrijft die luidt invoer vanaf het toetsenbord, laat
het invoer vanaf het toetsenbord lezen, niet doen laat het een string controleren of de
output weergeven of iets dergelijks.
Functies moeten klein zijn, en ze moeten erg samenhangend zijn.
Maar verdeel en heers strategie is echt leuk omdat
het die complexiteit vermindert.
In plaats van een hoofdfunctie te hebben met 5000 regels code kun je
heel veel functies hebben die: zijn bezig met specifieke taken en je
kunt ze heel snel herkennen.
Dus functies gaan naar: verdubbeling van code te verminderen.
En wanneer u dubbel werk vermindert van code, het gaat u tijd
besparen bij het schrijven, testen en het debuggen van die code.
Het gaat ook weer verminderen de grootte van de broncode.
En waarom verminderen functies? duplicatie van code, want als je
een taak hebt in plaats van dat te doen taak steeds opnieuw en
opnieuw en steeds dezelfde code schrijven en nogmaals, je kapselt die taak in
een functie in en je gewoon roep de functie op, en de functie zal
het elke keer voor je doen, jij heb daar geen duplicatie.
Als je een bepaalde taak moet doen meerdere keren
in een programma, hoeft u alleen een geschikt een keer functioneren,
zoals ik al zei. Je hoeft niet schrijf die code meerdere keren.
Dus een programma kan dan gebruiken die functie wanneer nodig.
En je kunt ook hetzelfde gebruiken functioneren in verschillende programma's, en dat
is wat een bibliotheek vormt.
Dat hebben we gedaan, we hebben de
functie printf gebruikt, die afkomstig is uit de standaard input output bibliotheek.
En dat is maar één keer geschreven, en we roepen het keer op keer aan.
Als die functie niet bestond, zouden we moeten
de implementatie van die functie nemen en in onze programma en blijf het herhalen.
Dus functies kunnen veel besparen van tijd
en ze kunnen uw broncode verminderen en u kunt hergebruik ze keer op keer.
Het is dus ook een software hergebruik techniek.
Het helpt ook bij de leesbaarheid.
Wanneer u uw programma moduleert dat is wat u doet
wanneer u deze afzonderlijke functies maakt om het uitvoeren van specifieke taken, wordt
het programma veel beter georganiseerd.
Zoals ik al zei, als je een hoofdgerecht had? routine, een hoofdfunctie en
er zat heel veel code in, het gaat veel moeilijker te
volgen zijn dan een hoofdroutine die 5 functies aanroept en die functies doen specifieke taken.
Het helpt dus bij de organisatie van het programma.
Het helpt bij het onderhoud van het programma.
Het is veel gemakkelijker te lezen en gemakkelijker om de broncode te wijzigen of te repareren.
En onthoud, het onderhoud fase is de duurste fase van
de softwarelevenscyclus, dit is waar je je bugs
oplost, het programma is uitgebracht en waar u nieuwe functies toevoegt.
Hoe beter je programma is, hoe gemakkelijker het zal
zijn om te onderhouden.
Dus deze organisatie, deze leesbaarheid, dit kunnen volgen wat
er gebeurt in je broncode is erg belangrijk
en functies helpen enorm.
De verdeel en heers aanpak maakt het ook
mogelijk delen van het programma te ontwikkelen, te testen en onafhankelijk debuggen.
Als je daar in het echt bent wereld en
je begint aan code te werken, dat ga je merken programma's zijn echt heel groot.
En er zijn veel mensen aan deze programma's
werken, honderden misschien zelfs duizenden.
Als je al deze mensen aan het werk hebt op een programma, is het veel gemakkelijker
om aan dat programma te werken als je, als je doe deze verdeel-overwin-benadering als
je kleine taken hebt die: mensen doen en het is onafhankelijk.
Je raakt niet hetzelfde aan broncode en u kunt doorgaan
en taken veel gemakkelijker uitvoeren.
En als je dit doet en je hebt meerdere mensen die
aan een project werken, kan het de algehele ontwikkeling verminderen tijd die
opnieuw de onderhoudskosten verlaagt, de ontwikkelingskosten verlaagt.
De functies kunnen ook opnieuw worden gebruikt wat weer tijd zal besparen.
En weer doen we dat met de printf-functie, hergebruik die.
Maar jij wanneer je je eigen gebruiker schrijft gedefinieerde functies, kunt u ze keer op
keer opnieuw gebruiken in het programma.
Hergebruik van software is dus een groot, groot voordeel van functies.
Wanneer je denkt over deze functies.
Het andere leuke aan ontwerpen uw programma over functies is dat u het als
een zwarte doos wilt zien.
Wat het betekent als je wanneer je zie het als een zwarte doos, het enige waar
je aan denkt is de input naar de functie en de output.
En als je je alleen concentreert op de invoer in de uitvoer, zodat u
naar het ontwerp als geheel kunt kijken voordat u begint met implementeren.
En dus zullen functies in het algemeen krijg je in dit soort denken waar je
je kunt concentreren op design.
En ik zei dat design belangrijk is.
Design is wanneer je begint met plannen je programma uit, hoe je
het gaat organiseren, hoe? je gaat de code schrijven.
En het is belangrijk om deze planning te doen voordat u zelfs maar begint met de implementatie
die de code schrijft.
En door na te denken over functies en denkend aan
alleen inputs en outputs, kun je nadenken over hoe de programma wordt georganiseerd en
welke functies u moet maken.
U hoeft zich dus geen zorgen te maken over alleen uitvoering in de details.
En dit is belangrijk omdat de het eerste dat u
wilt doen voordat u code schrijft, is gewoon nadenken over design, je wilt niet beginnen na
te denken over implementatie.
Veel problemen die studenten hebben als ze voor de eerste keer code
schrijven, is dat? begin gewoon met de uitvoering.
Ze denken niet eens aan de probleem, ze denken niet hoe
ze het probleem gaan oplossen, ze beginnen gewoon met het schrijven van code.
Nooit een goede aanpak.
Als je aan schrijven denkt code en functies, beschouw het
als alleen invoer en uitvoer van de functie en het gaat je
helpen met je ontwerp.
Laten we daarom enkele voorbeelden bekijken.
We hebben ingebouwde functies gebruikt zoals: als printf en scanf, zoals ik al zei.
Die zitten in de standaard input output bibliotheek geleverd
door de c programmeertaal.
Dus we zijn enigszins bekend met wat een functie is omdat we het hebben
gebruikt, maar we hebben de boete niet doorstaan gedetailleerde details over
hoe u een functie definieert of hoe u daadwerkelijk slaagt gegevens naar een functie, zoiets niet.
Maar met de printf-functie, je had moeten merken dat er
wel gegevens voor nodig zijn.
U kunt gegevens doorgeven aan de functie.
De gegevens zijn de argumenten tussen de haakjes
achter de functienaam.
We gaan een hele hebben andere lezing over argumenten
en parameters om ze meer uit te leggen.
Maar begrijp dat op een hoog niveau u kunt gegevens doorgeven aan een functie.
En begrijp dat door te kijken bij de printf-functie.
Het eerste argument voor de printf functie die de
gegevens zijn die we eraan doorgeven, was een tekenreeks letterlijk, het waren al
die tekens tussen dubbele aanhalingstekens.
En dan hadden we ook nog argumenten die: er kunnen er 0 zijn of er waren
veel variabele argumenten, namelijk: een reeks variabelen of uitdrukkingen waarvan de
waarden moesten worden weergegeven.
Dus onthoud, als we een formaat hadden specificeerders in het eerste argument
zouden we dan de variabelen in . hebben dit in de volgende argumenten.
Dus kon je slagen gegevens naar de printf-functie.
Je had ook moeten zien hoe je informatie kan terugkrijgen van een
functie, gegevens kunnen aan u worden geretourneerd.
In de scanf-functie, een van de argumenten was hoe je de
gegevens ging opslaan.
En dus zou je het doorgeven a variabele en die variabele zou wat dan ook
een waarde hebben de gebruiker heeft op het toetsenbord getypt.
Dus dat kan een beetje bedenken als een geretourneerde waarde in een functie.
Functies zijn dus erg waardevol omdat ze kunnen er gegevens in opnemen en vervolgens kunnen
ze er gegevens uit teruggeven.
Dus een codeervoorbeeld van een functie en dit zou gewoon een functie zijn die we
gaan aanroepen, maar dit is de belangrijkste functie.
We zijn bekend met de hoofdfuncties, het startpunt
van het programma.
Maar kijk eens hoe fijn dit is.
We roepen functies op lees lijst sorteren en gemiddeld.
We hebben maar 3 regels code.
Die moeten we gaan implementeren functies, maar het maakt het programma overzichtelijker
omdat we onmiddellijk weet wat dit programma doet.
Dit programma gaat lezen een lijst, het gaat dan een
lijst sorteren, het gaat dan naar geeft het gemiddelde van de lijst weer
en de lijst bevat floats.
Het is dus goed leesbaar, het gaat zeer gemakkelijk te onderhouden zijn.
Als we bugs hebben in de programma, weten we meteen hoe we
die bug kunnen vinden of isoleren.
Als de bug niet sorteert, zullen we kan naar de sorteerfunctie gaan.
Als de fout in de middeling zit, we kunnen naar de gemiddelde functie gaan,
heel gemakkelijk om fouten te isoleren.
Dus wanneer we die implementeren functies in de vorige
dia noemden we ze gewoon.
Om functies daadwerkelijk te implementeren, je moet de code in de hoofdtekst
van de functie schrijven.
U kunt ofwel functies gebruiken die: worden geïmplementeerd door de c-taal zoals printf
of u kunt maken uw eigen door de gebruiker gedefinieerde functies.
U hoeft de niet te implementeren printf-functies of een
van de functies in de bibliotheek, u implementeer alleen uw eigen functies.
Dus in dit vorige voorbeeld met de leeslijst sorteren en het gemiddelde, we zouden
moeten gaan en we zouden die functie moeten uitvoeren.
We zouden een functie moeten bieden header, een functie-body die daadwerkelijk de
lezing van . doet de lijst, het sorteren van
de lijst en het middelen van de lijst.
We zijn niet klaar door alleen te definiëren functies, we moeten ze implementeren.
En wanneer u de functies, wilt u
altijd beschrijvende functienamen gebruiken om duidelijk te maken wat het programma doet en
hoe het is georganiseerd.
In het vorige voorbeeld hadden we a functie met de naam leeslijst, vrij
duidelijk wat dat doet, functienaam sorteren.
We hebben de functie niet x y of z genoemd.
Die functie hebben we beschreven.
Het is hetzelfde wanneer je beschrijft
of creëert variabelen, betekenisvolle namen.
En ook als u deze functies maakt waar ze generiek genoeg zijn,
waar ze daadwerkelijk iets doen en ze nemen generieke gegevens, zou je eigenlijk
in staat zijn om hergebruik ze in andere programma's,
net als een bibliotheekfunctie.
Nogmaals, het ondersteunen van hergebruik van software.
Dus in deze komende lezingen, we gaan het hebben over hoe
we een functie kunnen definiëren, de specifieke syntaxis, hoe we een functie kunnen
aanroepen en aanroepen en hoe we dat kunnen gegevens van hen doorgeven en retourneren.
Daar gaan we ons op focussen in de komende colleges.
Dat wilde ik ook nog even melden onze belangrijkste routine die
we keer op keer hebben gezien in elke c programma, dat is een functie.
De belangrijkste functie is een speciaal herkende naam in het c-systeem,
geeft het aan waar de programma is om te beginnen met de uitvoering.
Alle c-programma's hebben altijd een main.
De belangrijkste functie kan duren: gegevens wanneer u ernaar
doorgeeft, de opdrachtregelargumenten of it hoeft geen gegevens op te nemen.
Het heeft ook optionele gegevens die het kan retourneren.
U zult merken dat we gebruik maken van hoofdfuncties die 0 retourneren.
Meestal wordt dat gebruikt wanneer u foutcodes wilt retourneren.
Maar we hebben specifieke functies gebruikt al en de belangrijkste
functie is die hoofdfunctie en dat helpt weer bij het organiseren van de code.
We weten altijd waar de programma wordt gestart omdat we
alleen de main moeten vinden.
Dit is een beschrijving op hoog niveau van functies soort van het identificeren van de
voordelen van functies en wat een functie precies is.
Nu willen we praten over uitvoering.
Dank u.