Functies

Home / Programmeren / Cplusplus / Functies

De meest simpele programma's bestaan uit 1 stuk code, maar als de code wat langer wordt is het makkelijker om de code op te splitsen in stukken, een hoofdcode en functies. Een functie is een klein stukje code dat een bepaalde taak uitvoert en telkens opnieuw kan worden gestart. Doordat een functie in een apart stukje geheugen zit is het niet zomaar mogelijk om variabelen uit de hoofdcode te gebruiken in een functie. Sterker nog, variabelen in functies worden verwijderd als de functie afgelopen is. Hoe dat allemaal werkt zul je zo zien.

Een functie maken en gebruiken

Een functie maken is helemaal niet moeilijk. Je hebt zelfs al de hele tijd met 1 functie gewerkt, de functie main. Normaal gesproken stuur je enkele variabelen naar de functie door (de argumenten), de functie doet er iets mee en stuurt een variabele terug.

#include <iostream>
using namespace std;

int eenfunctie(int argument1, int argument2)
{ return argument1 * argument2; }

int main()
{
cout << "5 keer 6 is " << eenfunctie(5,6) << endl;
return 0;
}

Natuurlijk is het bovenstaande voorbeeld niet echt nuttig, want voor een vermenigvuldiging hoef je echt geen functie te gebruiken! Het is wel handig om even uit te leggen wat er gebeurd.

  1. Je ziet int eenfunctie(int argument1, int argument2) staan. Dit betekend dat hier de functie eenfunctie begint en dat die 2 integer argumenten moet krijgen. Deze worden hier opgeslagen als argument1 en argument2. De int die je vooraan ziet staan en je ook kent van de functie main geeft aan dat waarde die de functie teruggeeft een integer is.
  2. return argument1 * argument2 vermenigvuldigd de argumenten met elkaar en stuurt de uitkomst terug naar het punt waarvandaan de functie werd aangeroepen.
  3. Een stuk verder wordt de functie aangeroepen met eenfunctie(5,6). Dit start de functie eenfunctie en geeft 2 argumenten, 5 en 6 mee. In dit geval wordt argument1 dus 5 en argument2 dus 6.

Een iets moeilijker voorbeeld

Zoals ik al heb gezegd is het vorige voorbeeld geen voorbeeld van functies zoals je die in het echte programmeren veel zult gebruiken. Vaak plaats je er een stukje code in dat op meerdere plaatsen in het programma gebruikt wordt. Een voorbeeld is een foutmelding. Als je programma in de soep loopt is het handig hiervan de gebruiker op de hoogte te stellen en er iets aan te doen. (de meeste gebruikers houden niet van vastgelopen programma's) Zie hiervoor het volgende voorbeeld waarin een programma een functie oproept die het programma afsluit zodra er iets mis gaat en een bericht aan de gebruiker stuurt.

#include <iostream>
#include <cstdlib>
using namespace std;

int foutmelding(int foutcode)
{ cout << "Dit programma is vastgelopen en wordt nu afgesloten" << endl;
cout << "Mocht dit vaker gebeuren, neem dan contact op met de ontwikkelaar" << endl;
exit(foutcode);
}

int main()
{
float invoer;
float berekening;

cout << "Hallo! Voer een getal in om te starten" << endl;
cin >> invoer;
// Ok, getal ingevoerd, we gaan 12 delen door het ingevoerde getal!
// Delen door 0 kan niet, dus we controleren of de invoer niet gelijk is aan 0
if(invoer == 0)
{
foutmelding(4); }
berekening = 12 / invoer;
cout << "He! Als je " << invoer << " deelt door 12 krijg je " << berekening << endl;

cout << "Dat was grappig! Typ nog eens wat in!" << endl; cin >> invoer;
// Ok, nog een getal. Dat vermenigvuldigen we met 21
// Alleen.... Als je vermenigvuldigd met 0 is de uitkomst niet grappig meer
// Laten we controleren of de invoer gelijk is aan 0
if(invoer == 0)
{
foutmelding(7); }
berekening = invoer * 21;
cout << "He! Als je " << invoer << " vermenigvuldigd met 21 krijg je " << berekening << endl;
return 0;
}

Het bovenstaande voorbeeld is ook nog redelijk simpel (en niet erg nuttig) maar geeft wel goed aan wat je met functies kan doen. Zoals je ziet roep ik de functie aan met 1 argument, namelijk de foutcode. De foutcode wordt in de functie zelf opgeslagen in de variabele genaamd foutcode. (dat kun je zien bovenaan de functie, tussen de haakjes achter de functienaam) De foutcode wordt doorgegeven aan de functie exit. Deze functie hebben we nog niet besproken, maar wordt vaak gebruikt om het programma te stoppen vanuit een functie.

Misschien is het je ook opgevallen dat return niet in de functie voorkomt. Dat kan hier omdat de functie het programma stopt. Het heeft daarom geen zin een return op te nemen, want die wordt toch nooit bereikt! Daarnaast is er bovenaan, bij de header, iets bijgekomen, #include <cstdlib>. Dat is nodig omdat de functie exit() niet in de iostream-bibliotheer zit, je moet dus een aparte bibliotheek toevoegen. In de volgende tutorials zul je cstdlib steeds vaker tegenkomen.

Commentaar

Daarnaast heb ik nog iets gebruikt, namelijk commentaar. Dat is datgene wat achter de 2 schuine strepen staat. We hebben al heel even commentaar gebruikt in de eerste tutorial. Commentaar doet helemaal niks aan het programma, het maakt alleen de code duidelijker. Het maakt je programma ook niet langzamer of groter. Het is belangrijk dat je bij programma's commentaar neerzet, omdat je dan ook straks snapt wat dat stukje code doet. We zullen commentaar nog vaak gaan gebruiken!

Ik kan me voorstellen dat dit laatste een beetje snel ging. Lees het anders nog eens een keer door. Mocht je nog vragen hebben, wacht dan niet je vraag te stellen op het forum!