Hallo en welkom.
In deze lezing wil ik praten over argumenten en parameters.
Deze termen zijn meestal: door elkaar gebruikt.
Wat ze te maken hebben met zijn in feite gegevens die u
doorgeeft aan een functie.
Dus een parameter is een variabele en een functiedeclaratie en
een implementatie van een functiedefinitie.
Onthoud, dit verschil tussen functiedeclaratie,
functieprototype en functiedefinitie.
Functiedeclaratie is alleen de handtekening van de methode,
het is de functiekop.
Functiedefinitie is de implementatie
van de functie, de eigenlijke code.
In beide termen: verklaring definitie, begrijp
die verschillen.
Maar de parameter is wat er in zit de functiedeclaratie en -definitie,
het staat in die kop.
Omdat zowel de koptekst is inbegrepen in de definitie in de aangifte.
Wanneer een functie wordt aangeroepen, wordt de argumenten zijn de gegevens die u doorgeeft
aan de functieparameters.
Dat is de werkelijke waarde van een variabele die aan
de functie wordt doorgegeven.
Dus functieparameters gedefinieerd binnen de functiekop, en hun tijdelijke
aanduidingen voor de argumenten die moeten worden opgegeven wanneer de
functie wordt aangeroepen.
Dus begrijp het verschil hier tussen argumenten en parameters.
Parameters hebben te maken met de functiedefinitie en verklaring.
Argumenten zijn waar je bent de functie aanroepen,
wanneer u de functie aanroept, de gegevens die u doorgeeft.
Dus argumenten worden gebruikt wanneer u een beroep doet.
Je zult zeggen dat dit de argumenten zijn die naar mijn functie gaan.
En wanneer de functie ontvangt die gegevens, ze
worden de parameters genoemd.
De parameters voor een functie zijn een lijst van parameternamen met
hun datatypes.
Elke parameter is gescheiden door een komma.
De volledige lijst met parameters is: tussen haakjes achter de naam van
de functie.
Een functie kan no . hebben parameters, wat betekent dat
er geen gegevens aan worden doorgegeven.
En in dit geval heb je gewoon de haakje links en rechts met een lege
ruimte ertussen of leeg, jij kan het nog steeds als leeg hebben, niets ertussen, maar het is een
goede gewoonte om er een leegte tussen te maken.
Void is een speciaal sleutelwoord dat betekent niets, betekent geen parameters
of geen retourgegevens.
Parameters bieden de middelen gegevens doorgeven aan een functie.
Gegevens doorgegeven van de aanroepende functie naar de functie die wordt aangeroepen, de aanroep
e aan de ontvangende kant, de bellende kant en de ontvangende kant.
De namen van de parameters zijn lokaal voor de functie.
Daar gaan we het over hebben als we het hebben over lokale gegevens.
Maar alleen die parameternamen bestaan in het functielichaam.
Ze nemen de waarden van de argumenten die eraan worden doorgegeven.
Dus als je een functie hebt genaamd optellen, je geeft een
variabele door als argument, je geeft de waarde door 5 en je hebt
een functie met een parameter x, x wordt gelijk tot 5 ergens in de functietekst.
Het lichaam van de functie: moet deze parameters gebruiken
bij de implementatie ervan.
Als dat niet het geval is, dan niet had mogen passeren.
Als je een parametervariabele hebt gedefinieerd in uw functiedeclaratiedefinitie
en u gebruikt die nooit variabele in de functie, dat is verspilling, neem het niet op
omdat dat wil gewoon zeggen dat je het niet nodig hebt.
Verstuur geen gegevens naar een functie die het niet gebruikt.
Een functielichaam kan extra hebben: lokaal gedefinieerde variabelen die nodig
zijn voor de functie-implementatie.
Je hebt misschien binnen de functie body andere variabelen gedeclareerd omdat
ze nodig zijn voor welke taak u ook uitvoert.
Je opereert niet alleen op gegevens die eraan worden doorgegeven.
U kunt werken op lokale gegevens binnen de functie.
Bij het doorgeven van een array als an argument aan een functie,
moet u ook een extra argument doorgeven, laat een andere parameter definiëren die de
grootte van de array specificeert.
De reden hiervoor is dat de functie heeft geen manier om te weten hoeveel elementen
zich in de array bevinden.
Dus zelfs als je een array van grootte 50, mag
u slechts 30 elementen opslaan.
En als je dat gaat gebruiken array in de hoofdtekst van de functie,
zul je waarschijnlijk moeten weet hoe groot het is, want je zult een van
beide nodig hebben er doorheen met een lus of je
moet toegang krijgen tot elementen.
En als uw toegangselementen door het itereren,
moet je weten of wanneer je buiten de grenzen bent.
En we hebben het gehad over de out of grenzen daar en waarom dat belangrijk is.
Nou, hier is een voorbeeld.
Wanneer de printf-functie is aangeroepen, geef je altijd een of
meer waarden op als argument.
De eerste waarde is dat tekenreeks tussen dubbele aanhalingstekens.
De overige waarden zijn willekeurig variabelen weer te geven.
Dit is eigenlijk een functie die: neemt een variabel aantal argumenten die
we waarschijnlijk niet gaan bespreken ongeveer aangezien dit een beginnersklasse is, is
dat meer een geavanceerd concept.
Maar de printf-functie is een goed voorbeeld
wat betreft het doorgeven van gegevens omdat je voorbijgaat meerdere sets
gegevens eraan, ofwel de tekenreeks tussen de aanhalingstekens of variabelen die u wilt weergeven.
Dit is waarom het zo belangrijk is om gegevens kunnen doorgeven aan een functie.
Het vergroot het nut enorm! en de flexibiliteit van een functie.
Als functies niet over de mogelijkheid om gegevens te accepteren, zouden ze
niet zo nuttig zijn.
In het voorbeeld dat ik gaf in de laatste lezing
waar we een functie hadden die werd weergegeven output, het deed niet echt veel.
Het was erg statisch.
Het deed hetzelfde elke keer dat u het aanroept.
Maar wat als je een functie had? waarvoor gegevens zijn verzameld, kunt u
bepalen wat er wordt weergegeven.
Dus net als de printf-functie.
Als de printf-functie dat niet deed parameters hebben, zou je niet kunnen
zeggen wat het moet weergeven.
Als je geen gegevens hebt geaccepteerd, heb je zou niet kunnen zeggen,
hey, deze variabele of deze string weergeven.
Het zou niet erg handig zijn.
Dus je wilt kunnen slagen gegevens naar een functie maakt,
het veel nuttiger en flexibeler.
En dat zul je zien.
Ik bedoel als we vermenigvuldigen functie, zou je niet hetzelfde
willen vermenigvuldigen telkens twee cijfers.
Je zou parameters en gegevens nemen zou worden doorgegeven aan het voor twee nummers.
Dus je zou verschillende berekeningen kunnen doen op basis van de gegevens die eraan worden doorgegeven.
Heel, heel belangrijk om te begrijpen gegevens doorgeven en waarom het nuttig is.
Het is ook een goed idee om toe te voegen opmerkingen vóór elk
van uw eigen functiedefinities.
Het helpt uit te leggen wat de functie gaat doen en hoe
de argumenten moeten worden gebruikt.
Dit zie je meestal.
Dit zie je terug in mijn voorbeelden.
Je hebt de functiedeclaratie bovenaan het bestand heb
je de functiedefinitie.
Functiedefinitie omvat: de functiekop.
Rechts boven de functie header, hebt u opmerkingen,
meestal opmerkingen met meerdere regels.
Dus je hebt de schuine streep, asterisk.
En daar zeg je de naam van de functie, het doel van de functie en
beschrijf vervolgens ook eventuele gegevens dat wordt doorgegeven aan de functie.
Dit, nogmaals, is voor onderhoud en veel sneller fouten
kunnen vinden en oplossen.
Meestal wil je een goede naam voor de functie die
je iets zal vertellen.
Maar met aanvullende opmerkingen, het zal je nog meer vertellen.
Hier is een voorbeeld dat een functie is dat twee getallen vermenigvuldigt, dat krijgt dat er
gegevens aan worden doorgegeven.
We hebben onze twee getallen vermenigvuldigen.
We weten dat het een functie is omdat: het heeft in wezen de parameters.
Het heeft de haakjes.
Dat is een manier waarop je je kunt identificeren functies wanneer u haakjes ziet.
Ik bedoel, we konden ons ook identificeren omdat het een retourtype heeft.
Er zijn meerdere dingen die vertel ons dat het een functie is.
Maar het belangrijkste zijn de haakjes en dan zie je ook de haakjes, de
accolades die de . betekenen begin en einde van het blok.
Dit vermenigvuldigt twee cijfers functioneren wel.
Onthoud dat de functieparameters worden gedefinieerd tussen de haakjes en vervolgens
gescheiden door komma's.
Hier hebben we twee parameters.
We hebben een parameter met de naam x en een parameter met de naam y.
Voor elke parameter, u moet het gegevenstype
identificeren dat binnenkomt.
Dus hier hebben we twee ints.
Dit is de standaardmanier om gegevens doorgeven en hoe u dit moet doen.
Tussen de haakjes, data typ vervolgens een naam voor de variabele.
De naam voor de variabele omdat alles wat geldig is in c voor de
naam van een variabele, zou je kunnen noem dat x y z hoe je maar wilt.
Je kunt er gewoon niet aan beginnen met een dollarteken.
En dan scheid je die door komma's, wennen aan
deze conventie, parameters tussen haakjes.
Als u geen parameters had, geen gegevens dat is doorgegeven
aan de functie, wat je daartussen zou zien haakjes zijn ongeldig, anders ziet u
niets tussen de haakjes.
Deze functie is alles wat het gaat doen gaat het de gegevens
gebruiken die eraan zijn doorgegeven, wat twee variabelen zijn? heet nu x en y, en het gaat ze met elkaar vermenigvuldigen en
opslaan in een variabele met de naam resultaat of in dit geval lijkt het alsof
ik het verkeerd heb gespeld t.
En wat doet het dan? of het gegevens afdrukt.
Het drukt de gegevens af dat wordt vermenigvuldigd.
Maar nogmaals, zie de flexibiliteit en het nut van de functie omdat
er gegevens voor nodig zijn.
Het kan verschillende tonen: gegevens op basis van wat u doorgeeft.
Wanneer we de functie aanroepen in de hoofdroutine hier, we zeggen vermenigvuldig twee
getallen en we geven de argumenten door.
We geven de waarde 10 en 20 door.
We kunnen variabel doorgeven hier ook namen
Maar in dit voorbeeld zijn we... zeg maar 10 en 20.
Dit gaat de functie aanroepen vermenigvuldig twee getallen
en het gaat door in data 10 voor de eerste parameter 20 voor de tweede.
Dus x wordt gelijk aan 10, y wordt gelijk aan 20.
Dus als we onze vermenigvuldiging x . doen keer y, het wordt 10 keer
20, het resultaat wordt opgeslagen 200 en
dan zal het dat resultaat samen met de variabelen weergeven die worden doorgegeven aan x y en z.
Dus het wordt weergegeven 10 20 en dan 200.
Merk ook op dat we kunnen hergebruik deze functie nu.
We noemen het nog een keer met verschillende gegevens, gegevenswaarden 20 en 30 in onze
tweede regel hier in de hoofdfunctie.
En dan noemen we het weer a derde keer om 50 met 2 te vermenigvuldigen.
Heel handig om te kunnen doen dit om een functie
te maken die verschillende gegevens nodig heeft, maakt het herbruikbaar, maakt het flexibel.
En de syntaxis is heel gemakkelijk te volgen.
Het zijn slechts twee variabelen binnenin de haakjes gescheiden door komma's.
En om het dan even te noemen gemakkelijker, je plaatst gewoon
een naam en je hebt de twee gegevens.
Welke gegevens ook worden gescheiden door gemeenschappelijke kant haakjes en dan
eindigend met een puntkomma.
Je kunt elke vorm van gegevenstype in een functie.
U kunt een array doorgeven.
We gaan het ook hebben over hoe u kunt andere gegevenstypen doorgeven.
We hebben hier eenvoudige voorbeelden, maar je kunt ook pointers doorgeven, waar we het nog niet
over hebben gehad.
Je kunt in structuren passen.
Nogmaals, een ander concept we hebben het niet over gehad.
Maar het wordt echt echt zinvol en nuttig wanneer u hier
gegevens doorgeeft.
Dit is een eenvoudig voorbeeld.
Let op de syntaxis, bestudeer dit en zal een goede uitdaging voor
je zijn waar je een schrijft aantal verschillende functies.
Dank u.