Welkom, jonge leerlingen! Vandaag gaan we leren over besturingsstructuren in computerprogrammering. Besturingsstructuren zijn als de verkeersborden voor een computerprogramma. Ze vertellen het programma welke kant het op moet en wat het vervolgens moet doen. Net zoals jij je thuis of op school aan regels houdt, volgt een computer besturingsstructuren bij het uitvoeren van een programma.
Een besturingsstructuur is een set instructies die een computer vertelt hoe hij moet kiezen tussen verschillende stappen bij het uitvoeren van een programma. Deze bepaalt of de computer in dezelfde volgorde moet blijven werken of een andere beslissing moet nemen.
Stel je voor dat je een recept volgt. Het recept vertelt je elke stap: eerst meng je de bloem en het water; dan voeg je een ei toe; vervolgens roer je; en tot slot bak je het mengsel. In een computer werken regelsystemen op een vergelijkbare manier. Ze helpen de computer te weten welke instructie er volgt en welke beslissing hij moet nemen wanneer er keuzes zijn.
Er zijn drie hoofdtypen controlestructuren waar u vandaag meer over leert. Deze zijn:
Sequentiële besturingsstructuren vertellen de computer om instructies één voor één in een vaste volgorde op te volgen. Bij sequentiële besturing is er geen sprake van besluitvorming. Elke stap vindt plaats in een reeks, net als wanneer je een eenvoudige reeks instructies volgt.
Denk bijvoorbeeld eens aan uw dagelijkse ochtendroutine:
Elke activiteit vindt één voor één plaats in een duidelijke volgorde. In de programmering wordt dit sequentiële uitvoering genoemd. De computer leest de eerste instructie, dan de tweede en dan de derde.
Als we denken aan een eenvoudig pseudo-programma voor het maken van een sandwich, zou dat er zo uit kunnen zien:
Stap 1: Neem twee sneetjes brood.
Stap 2: Smeer boter op één sneetje.
Stap 3: Leg de kaas op de boter.
Stap 4: Leg de twee sneetjes op elkaar. Eet smakelijk!
Net als bij de sandwich die u maakt, voert de computer de instructies één voor één uit.
Selectiecontrolestructuren stellen de computer in staat keuzes te maken. Ze werken als een splitsing in de weg of een 'kies je eigen avontuur'-boek. De computer kijkt naar een voorwaarde of een regel en beslist vervolgens welk pad hij moet volgen.
Denk bijvoorbeeld aan het kiezen van je kleding 's ochtends. Je zou kunnen besluiten: "Als het regent, draag ik een regenjas. Als het zonnig is, draag ik een T-shirt." Deze beslissing helpt je om voorbereid te zijn op het weer. Bij het programmeren gebruikt de computer if- , else- en else- statements om beslissingen te nemen.
Een eenvoudig codevoorbeeld in gewone taal ziet er als volgt uit:
Als het regent, print dan "Neem een paraplu mee."
Anders , print "Geen paraplu nodig."
Dit betekent: als de voorwaarde (regenen) waar is, voer dan de handeling uit (pak een paraplu). Anders voer je de andere handeling uit.
Laten we een ander voorbeeld nemen. Stel je voor dat je een spel speelt en er is een regel die zegt: "Als je 10 punten scoort, win je!" Deze regel is vergelijkbaar met een selectiecontrolesysteem. Het spel controleert of je punten gelijk zijn aan 10. Zo ja, dan wordt je tot winnaar uitgeroepen. Zo niet, dan speelt het spel verder.
Selectiestructuren helpen computers bij het nemen van beslissingen die slechts een paar mogelijke antwoorden hebben. Ze vertellen de computer: "Doe dit als het waar is, en als het niet waar is, doe dan iets anders."
Iteratiecontrolestructuren vertellen de computer om iets steeds opnieuw te doen. Dit staat bekend als lus- of herhalingsacties. Wanneer een taak vaak herhaald moet worden, wordt iteratie gebruikt.
Denk eens aan het tellen van het aantal appels in een mandje. Je kunt tellen: 1, 2, 3, 4, 5, enzovoort. Je begint bij één getal en blijft tellen tot je het einde hebt bereikt. Dit is vergelijkbaar met hoe een computer lussen gebruikt.
Er zijn twee veelvoorkomende soorten lussen in de programmering:
Een for-lus wordt gebruikt als je weet hoe vaak je iets wilt herhalen. Als je bijvoorbeeld dezelfde regel van een liedje vijf keer wilt zingen, kun je een for-lus gebruiken:
Zing voor (tel van 1 tot 5) de zin: "Happy Birthday!"
De computer zal vijf keer "Gefeliciteerd!" zeggen, omdat de stap vijf keer wordt herhaald.
Een while-lus wordt gebruikt wanneer de computer iets moet blijven herhalen zolang aan een voorwaarde wordt voldaan. Als je bijvoorbeeld een ballon opblaast, kun je doorgaan met blazen tot de ballon groot genoeg is. De regel zou kunnen zijn: "Blijf lucht in de ballon blazen zolang deze niet groot is."
Dit is vergelijkbaar met zeggen: Zolang (de ballon klein is), blijf blazen. Als de ballon groot genoeg is, stop je de lus.
Hier is nog een eenvoudig voorbeeld met een lus: Stel je voor dat je graag in je handen klapt. Je besluit om in je handen te klappen totdat je 10 keer hebt geklapt. Je zou kunnen zeggen: Herhaal "Klap" 10 keer. In een programma telt de computer elke klap en stopt wanneer hij 10 keer heeft geklapt.
Besturingsstructuren zijn erg belangrijk bij het programmeren. Ze helpen bij het organiseren van de taken in een programma, zodat het correct werkt. Zonder deze structuren zou een computer niet weten hoe hij beslissingen moet nemen of acties moet herhalen.
Hier zijn enkele redenen waarom controlestructuren essentieel zijn:
Laten we eens een aantal voorbeelden uit het dagelijks leven bekijken die de besturingsstructuren in de programmering weerspiegelen.
Voorbeeld van sequentiële besturing:
Stel je voor dat je je klaarmaakt voor school. Eerst word je wakker. Dan was je je gezicht. Daarna trek je je kleren aan. Ten slotte eet je je ontbijt. Dit is een reeks handelingen die je achter elkaar uitvoert. In computerprogrammering wordt sequentiële controle gebruikt wanneer elke instructie zonder voorwaarden wordt uitgevoerd.
Voorbeeld van selectiecontrole:
Denk eens na over de beslissing die je neemt bij het kiezen van je kleding. Als het koud is, draag je een warme trui. Als het warm is, draag je een T-shirt. Dit besluitvormingsproces is vergelijkbaar met hoe een computer een "als"-statement gebruikt. De computer controleert het weer (de weersomstandigheden) en kiest vervolgens de juiste kleding (de actie).
Voorbeeld van iteratiecontrole:
Stel je voor dat je een klusje doet, zoals je speelgoed opruimen. Je hebt misschien wel veel speelgoed om op te ruimen. In plaats van elk stuk speelgoed één voor één te bekijken, herhaal je simpelweg dezelfde handeling: pak een stuk speelgoed op, doe het in de speelgoedkist en ga door naar het volgende stuk speelgoed totdat alles is opgepakt. Dit is een herhalende actie, net als een lus in programmeren.
Soms kunnen besturingsstructuren in elkaar worden geplaatst. Dit wordt een geneste besturingsstructuur genoemd. Dit gebeurt wanneer de ene beslissing of lus zich in een andere bevindt. Stel je een spel voor waarbij je in verschillende stappen keuzes maakt. Je zou bijvoorbeeld eerst kunnen beslissen of je naar links of rechts gaat. Als je links kiest, kun je vervolgens voor een andere keuze komen te staan: "Klim je de heuvel op of loop je eromheen?" Elke keuze is een kleine beslissing en ze worden achter elkaar genest.
Nesting stelt de computer in staat om complexere taken uit te voeren bij het coderen. Zelfs een simpele game of applicatie kan meerdere lagen met beslissingen en lussen hebben. Wanneer deze lagen samenwerken, kan het programma slimmere beslissingen nemen en spannendere dingen doen.
Stel je bijvoorbeeld een programma voor dat je helpt bij het plannen van een picknick. Het zou je eerst kunnen vragen: "Is het mooi weer?" Als het antwoord ja is, vraagt het programma vervolgens: "Heb je genoeg eten?" Als je nogmaals ja antwoordt, zegt het: "Geweldig! Tijd om te gaan picknicken!" Als een van de antwoorden nee is, stelt het een ander plan voor. Deze geneste besluitvorming helpt de computer je keuzes beter te begrijpen.
Wanneer een computerprogramma draait, volgt het de instructies die u hebt gegeven in een specifieke volgorde. Laten we eens denken aan een eenvoudig programma dat een begroeting op het computerscherm weergeeft. Het programma zou het volgende kunnen doen:
Stap 1: Start het programma.
Stap 2: Controleer de tijd van de dag.
Stap 3: Als het ochtend is, laat u "Goedemorgen!" horen.
Stap 4: Als het middag is, toon dan "Goedemiddag!"
Stap 5: Als het avond is, toont u "Goedenavond!"
Stap 6: Beëindig het programma.
In dit programma is er een duidelijke volgorde. Er is ook een beslissing over wat er op het scherm wordt weergegeven. De computer gebruikt een selectiecontrolestructuur (de if-else statements) om die beslissing te nemen.
Stel je vervolgens voor dat je een eenvoudig computerspel speelt waarbij je munten moet verzamelen. Het programma kan een lus gebruiken om te controleren wanneer je één munt verzamelt. Het programma telt je munten terwijl je ze verzamelt. Zodra je alle munten hebt verzameld, is het spel afgelopen. De lus is hier de iteratiecontrolestructuur die het telproces herhaalt.
Regelstructuren worden niet alleen gebruikt in schooloefeningen of kleine programma's. Ze worden gebruikt in veel praktische toepassingen die we dagelijks zien. Hier zijn enkele interessante voorbeelden:
Deze voorbeelden laten zien dat besturingsstructuren alomtegenwoordig zijn! Ze helpen moderne apparaten en programma's zo soepel mogelijk te werken, waardoor ons leven makkelijker en leuker wordt.
Laten we een eenvoudig pseudocodevoorbeeld schrijven. Pseudocode is een manier om programma's te plannen met behulp van eenvoudige woorden die op code lijken.
Voorbeeld: een eenvoudige beslisser voor snacks
Stel je voor dat je wilt beslissen of je een appel of een banaan als tussendoortje neemt. Je kunt de regels als volgt opschrijven:
Als je honger hebt en iets zoets wilt, kies dan een appel.
Als je honger hebt en iets zachts wilt, kies dan voor een banaan.
Ga anders zitten en denk na over wat je wilt.
Deze pseudocode vertelt de computer: Kijk eerst of je iets zoets wilt. Als dat zo is, kies dan een appel. Zo niet, kijk dan naar iets anders, zoals een banaan. Als geen van de opties overeenkomt, neem dan even de tijd om te beslissen.
Het kan helpen om controlestructuren te zien als een kaart. Stel je een simpele schatkaart voor. De kaart heeft een gemarkeerd pad met de stappen in de juiste volgorde. Wanneer je bij een splitsing komt, geeft de kaart aan welke kant je op moet gaan op basis van een aanwijzing uit de schat. Soms vertelt de kaart je dat je hetzelfde pad meerdere keren moet volgen tot je de schat bereikt. Al deze instructies helpen je de juiste weg te vinden.
Op dezelfde manier gebruikt een computer opeenvolgende stappen om de kaart te volgen, selectie om het juiste pad te kiezen bij splitsingen, en iteratie om taken te herhalen totdat een doel is bereikt. Door gebruik te maken van controlestructuren kunnen we een computer precies vertellen hoe hij zijn "schat" kan bereiken – het juiste resultaat.
Laten we de belangrijke ideeën die we vandaag hebben geleerd nog eens doornemen:
