Flow control

Met C++ heb je diverse mogelijkheden om het verloop van je programma te bepalen. Die zijn in te delen in twee groepen: beslissingen en herhaling.

Beslissingen (conditions)

Beslissingen (in 't Engels: conditions) bepalen of een stuk code wel of niet uitgevoerd wordt, afhankelijk van het optreden van een bepaalde situatie. Men zegt ook wel: als er "aan een bepaalde conditie voldaan wordt" of dat bepaalde code "conditioneel wordt uitgevoerd".

if, else

Dit is de eenvoudigste vorm van een beslissing: als de conditie waar is wordt de code tussen { en } uitgevoerd en anders gebeurt er niks.

if(true)
{
  std::cout << "Dit is altijd waar" << std::endl;
}//if

if(false)
{
  std::cout << "Dit wordt nooit uitgevoerd" << std::endl;
}//if

In het volgende geval wordt als a > b de regel "a is groter dan b" geschreven. Als a niet groter is dan b, dan gebeurt er niks.

if(a > b)
{
  std::cout << "a is groter dan b" << std::endl;
}//if

Je kunt ook iets doen als a niet groter is dan b, dat zet je dan tussen de {} haakjes na het 'else' statement:

if(a > b)
{
  std::cout << "a is groter dan b" << std::endl;
}//if
else
{
  std::cout << "a is kleiner dan b of gelijk aan b" << std::endl;
}//else

switch

Met een switch kun je een keuze maken uit verschillende mogelijkheden. Kijk eerst eens naar het volgende stukje code:

if(huisnummer == 1) {
  std::cout << "Hier woont mevrouw Jansen" << std::endl;
}
else if(huisnummer == 3) {
  std::cout << "Hier woont de familie de Boer" << std::endl;
}
else if(huisnummer == 5) {
  std::cout << "Dit is een spookhuis" << std::endl;
}
else {
   std::cout << "Dit huisnummer is onbekend" << std::endl;
}//if

Met een switch ziet dat er veel overzichtelijker uit en het is bovendien efficienter omdat niet telkens de waarde van huisnummer hoeft te worden opgehaald en vergeleken:

switch(huisnummer) {
   case 1: std::cout << "Hier woont mevrouw Jansen" << std::endl;
   break;
   case 3: std::cout << "Hier woont de familie de Boer" << std::endl;
   break;
   case 5: std::cout << "Dit is een spookhuis" << std::endl;
   break;
   default:
   std::cout << "Dit huisnummer is onbekend" << std::endl;
}//switch

Herhaling (loops)

Herhalingen (in 't Engels: loops) zijn stukjes code die herhaaldelijk uitgevoerd kunnen worden, tot er aan een bepaalde conditie voldaan wordt.

while

int teller = 0;

while(teller < 10)
{
  std::cout << "teller: " + teller << std::endl;
  teller++;
}//while

do...while

int teller = 0;

do {
  std::cout << "teller: " + teller << std::endl;
  teller++;
} while(teller < 10);

Het verschil tussen while(cond){...} en do{...}while(cond) zit erin dat de code binnen de {} haakjes van do{...}while(cond) altijd minimaal 1 keer wordt uitgevoerd en bij while(cond){...} kan het ook gebeuren dat het helemaal niet wordt uitgevoerd. Dat ligt aan het punt waarop de beslissing wordt genomen om te stoppen met de loop. Bij while(){...} is dat al aan het begin en bij do{...}while() pas aan het eind, dus wanneer de code al 1 keer is uitgevoerd.

for

Tussen de haakjes van een for-loopje staan drie stukjes code:

for(initialisatie; conditie; increment) { doe iets }

initialisatie wordt gedaan voordat de eigenlijke loop begint
conditie wordt aan het begin van elke loop-iteratie bekeken en zo lang deze nog true is wordt een nieuwe iteratie gedaan
increment wordt na elke iteratie uitgevoerd

Met iteratie bedoelen we het uitvoeren van alle code die staat tussen de { en } na het for-statement.

Een veel voorkomende toepassing van 'for' is een teller te maken die een aantal waarden doorloopt:

for(int teller=0; teller < 10; teller++)
{
  std::cout <<  "teller: " + teller << std::endl;
}//for

foreach

Een loop die alle elementen in een container afgaat kun je met de bovenstaande while en for maken, maar sinds C++ 11 is er een manier die syntactisch overzichtelijker is en lijkt op wat in veel andere programmeertalen foreach heet. Dit kun je toepassen op arrays en andere containers zoals list, map, set etc...

Voorbeeld van een array met elementen:

int array[] {1,7,2,9,8};

    for (auto element : array) {
        std::cout << element << std::endl;
} //for

break, continue

De break hadden we al gezien in de switch. Met break wordt de loop meteen afgebroken. Je kunt ook continue gebruiken. Daarmee spring je terug naar het begin van de loop en wordt de code na continue overgeslagen.

int teller = 0;

while(teller < 10)
{
  std::cout << "teller: " + teller << std::endl;
  teller++;
  if(teller==5) break;
}//while

Flow charts

In een flow chart geef je de 'flow' van je programma aan. Alle punten waarbij je een beslissing neemt of je een bepaald stuk code wel of niet uitvoert zijn hierin verwerkt. Zo krijg je een duidelijk beeld van alle verschillende paden die je programma kan doorlopen. Een voorbeeldje:

Flow control: if, switch, while, for...