Programmeren in

C++
Handleiding voor de studierichtingen:
Elektriciteit/Elektronica
Industriële Wetenschappen

#include <iostream> // Dit regelt de standaard in- en uitvoer binnen C++

using namespace std;

int main() // De uitvoering van het programma begint bij main()

{
cout << “Hello world!” // Schrijf "Hello World!"
endl;
}

ing. Roger D’Joos

 Deze pagina is met opzet blanco gelaten.

2 Programmeren in C++ - ing. Roger D’Joos

 Beginselen van C++

1 Inleiding
1.1 Wat is C++?
C++ is een programmeertaal gebaseerd op C.
In tegenstelling tot C is C++ een multi-paradigma programmeertaal, er kunnen
verschillende programmeertechnieken worden gebruikt. De taal is ontworpen door
Bjarne Stroustrup voor AT&T Labs, als verbetering van C. De naam is afkomstig van de
programmaopdracht "C++", wat betekent: verhoog de waarde van de variabele C met 1.

1.2 Voor wie is deze handleiding bedoeld?

Deze handleiding is voor iedereen die wil leren programmeren in C++ en nog geen of
weinig ervaring met programmeren en programmeertalen heeft.
Elk hoofdstuk van deze handleiding bevat een aantal voorbeelden zodat de verworven
theoretische kennis meteen in praktijk kan worden omgezet. Door aan de bestaande
voorbeelden wijzigingen aan te brengen en nieuwe functionaliteiten toe te voegen, kan
extra kennis en ervaring worden opgedaan. Praktijk is de beste leerschool!

1.3 Compilers
De voorbeelden in deze handleiding zijn console programma’s. Dit betekent dat tekst
wordt gebruikt om met de gebruiker te communiceren. Alle C++ compilers
ondersteunen het compileren van console programma’s. Sla er even de handleiding van
jouw compiler op na hoe dit precies in zijn werk gaat.
Er bestaan verschillende C++ compilers die gratis te downloaden zijn, o.a.:
- Bloodshed Dev-C++
- Open Watcom C/C++
- Code::Blocks C++ IDE

In deze handleiding wordt laatstgenoemde compiler gebruikt. Hij is de downloaden via

volgende link:
http://www.codeblocks.org

Programmeren in C++ - ing. Roger D’Joos 3

Beginselen van C++

2 Beginselen van C++

2.1 Structuur van een C++ programma
De enige manier om een programmeertaal te leren is door programma’s te schrijven!
Ons eerste programma:

//mijn eerste programma in C++ Hello World!

#include <iostream>
using namespace std;
int main()
{
cout << "Hello world!";
return 0;
}

Links wordt de broncode (source code) van ons eerste programma getoond. Rechts
daarvan het resultaat na compilatie en uitvoering. De manier van compileren is
afhankelijk van de gebruikte compiler.
Met dit kleine programma zet haast elke C++ programmeur zijn eerste stappen. Het
schrijft de woorden “Hello World” op je computerscherm. Ondanks al zijn eenvoud bevat
het toch alle componenten van een C++ programma. Laten we de broncode even
overlopen.
//mijn eerste programma in C++
Dit is een commentaarlijn. Elke lijn code die begint met een dubbele schuine streep (//),
wordt door de compiler als commentaar beschouwd en heeft bijgevolg geen enkel
invloed op het verloop van het programma.
#include <iostream>
Lijnen die beginnen met een hekje (hash #) zijn richtlijnen of directives voor de
preprocessor. Dit zijn geen programmalijnen! In dit geval zal de directive #include
<iostream> de preprocessor zeggen om het standaardbestand iostream in het
programma op te nemen. Dit bestand bevat de declaraties van de basis in- en uitvoer
(input/output) bibliotheek (library) in C++ en wordt aan het programma toegevoegd
omdat we later een paar functies uit deze bibliotheek gebruiken. Deze bestanden
noemen we ook header files.
using namespace std;
Alle elementen van de standaard C++ bibliotheek worden gedeclareerd in wat een
namespace wordt genoemd, de namespace met de naam std. Een namespace is eigenlijk
een container die alle uitdrukkingen, ed. bevat.
int main ()
Deze lijn duidt aan waar het hoofdprogramma of main function begint en dit
onafhankelijk van de plaats in de broncode. Het doet er niet of er code voor of na deze

4 Programmeren in C++ - ing. Roger D’Joos

 Beginselen van C++

functie is gedefinieerd, alle instructies binnen deze functie worden eerst uitgevoerd in
elke C++ programma. Daarom is het belangrijk dat elk C++ een main function bevat.
Het woord main wordt gevolgd door een paar haakjes (). Dit komt omdat main een
functiedeclaratie is. In C++ maakt dit het verschil tussen een functie en elke andere
declaratie. Optioneel kan tussen de haakjes een lijst met parameters worden
opgenomen.
Onmiddellijk na de haakjes vinden we de inhoud van het hoofdprogramma ingesloten
tussen accolades (braces {}). Wat er tussen de accolades staat is wat de functie doet
wanneer ze wordt uitgevoerd.
cout <<”Hello World”!;
Dit is een C++ instructie of statement. Een uitdrukking is een enkele of samengestelde
uitdrukking die iets kan uitvoeren of realiseren. In ons programma is dit de enige
instructie die een zichtbaar effect heeft.
cout is gedeclareerd in de iostream bibliotheek binnen de std namespace. Nu begrijp je
meteen waarom we eerder deze bibliotheek moesten toevoegen en dienden te
vermelden dat we de specifieke namespace willen gebruiken.
Het valt meteen op dat de instructie eindigt met kommapunt (semicolon ;). Dit karakter
geeft het einde van een instructie aan. In feite dit karakter aan het einde van elke C++
instructie moeten worden toegevoegd. De meest voorkomende fout in C++ is het
vergeten toe te voegen van een “;” aan het einde van een instructie.
return 0;
Deze instructie beëindigd het hoofdprogramma en mag worden gevolgd door een
returncode (in ons voorbeeld is return gevolgd door de code 0). Een returncode 0 wordt
geïnterpreteerd als “het programma werkt zoals verwacht en zonder fouten”.
Het is je opgevallen dat niet alle programmalijnen in ons voorbeeld effectief iets “doen”
wanneer het programma wordt uitgevoerd. Er zijn commentaarlijnen (lijnen die
beginnen met //). Er zijn programmalijnen die richtlijnen geven aan de preprocessor
(lijnen die beginnen met #). En er zijn lijnen die een functie declareren (de functie main
in ons geval) en last but not least, programmalijnen met instructies of statements (cout
bijvoorbeeld).
Het programmavoorbeeld is structureel opgebouwd, voor de leesbaarheid is de code
opgedeeld in verschillende lijnen. Maar in C++ bestaan er geen strikte regels over hoe
we broncode moeten indelen. Zo hadden we bijvoorbeeld in plaats van:
int main()
{
cout << "Hello world!";
return 0;
}

net zo goed:
int main() {cout <<”Hello World!”; return 0;}

kunnen schrijven. Alles op één lijn en dit zo exact dezelfde betekenis hebben als de
voorgaande code.
Programmeren in C++ - ing. Roger D’Joos 5
Beginselen van C++

In C++ wordt de scheiding tussen de verschillende instructies bepaald door de

kommapunt (semicolon) aan het einde van elke instructie. Het opdelen in verschillende
lijnen doet er dus helemaal niet toe. Het is perfect mogelijk om meerdere instructies op
één lijn te schrijven of één enkele instructie te spreiden over meerdere lijnen.
Daar overzichtelijkheid en leesbaarheid belangrijk zijn voor een goed geschreven
programma, zal de broncode worden opgedeeld.
Laten we een extra lijn toevoegen aan ons voorbeeld.

//mijn tweede programma in C++ Hello World! I’m a C++ program.

#include <iostream>
using namespace std;
int main()
{
cout << “Hello world!”;
cout << “I’m a C++ program.”;
return 0;
}

In dit geval hebben we een extra instructie cout toegevoegd. Ook hier is voor de
duidelijkheid de broncode opgedeeld in één instructie per lijn. Het hoofdprogramma kan
ook als volgt worden geschreven:

int main(){cout << “Hello world!”;cout << “I’m a C++ program.”;return 0;}

Perfect leesbaar, voor de compiler dan toch!

Een ander manier om het probleem te benaderen kan als volgt:

int main ()
{
cout <<
"Hello World!";
cout
<< "I'm a C++ program";
return 0;
}

Het resultaat zal identiek zijn aan de vorige voorbeelden.

6 Programmeren in C++ - ing. Roger D’Joos

 Beginselen van C++

2.2 Commentaar
Commentaar(lijnen) worden door de compiler genegeerd. Maar voor de programmeur
zijn ze van onschatbaar belang, zij laten immers toe om het programma te
documenteren en te verduidelijken. Zonder het verloop van het programma te
beïnvloeden maken zij toch een deel uit van de broncode.
In C++ kan men commentaar als volgt invoegen:
//lijn commentaar
/*blok commentaar*/

In het eerste geval wordt alles vanaf de // tot het einde van de lijn beschouwd als
commentaar.
In het tweede geval, de block comment, wordt alles tussen /* en */ als commentaar
beschouwd. Hier bestaat de mogelijkheid om de commentaar over meer dan één lijn te
spreiden.
Laten we nu wat meer commentaar aan ons tweede programma toevoegen:

/* my second program in C++ Hello World! I’m a C++ program

with more comments */

#include <iostream>
using namespace std;

int main ()
{
cout << "Hello World! "; // prints Hello World!
cout << "I'm a C++ program"; // prints I'm a C++ program
return 0;
}

Wanneer je commentaar aan je programma toevoegt zonder de commentaarkarakters

// of /* en */ te gebruiken, zal de compiler deze als C++ instructies behandelen.
Resultaat: meerdere foutmeldingen!

Opdracht:
Schrijf een programma dat volgende boodschap op het scherm zet:
“Hallo, ik ben <voornaam> en zet mijn eerste stappen in het programmeren in C++.”
Voorzie je code van de nodige commentaar.

Programmeren in C++ - ing. Roger D’Joos 7

Variabelen en datatypes

3 Variabelen en datatypes
3.1 Inleiding
Het nut van het “Hello World!” programma is twijfelachtig. Verschillende lijnen
broncode schrijven, compileren en uitvoeren. Met als resultaat: één enkele zin op het
scherm. Deze zin meteen op het scherm zetten zou beslist sneller zijn geweest.
Programmeren is veel meer dan enkel één of meerdere lijnen tekst op een
computerscherm plaatsen. Voor we een programma kunnen schrijven dat iets zinvols
doet, eerst een woordje meer over variabelen.
Stel dat je wordt gevraagd om het cijfer 5 te onthouden, daarna ook het cijfer 2. Je hebt
dus twee cijfers in je geheugen opgeslagen. Nu moet je 1 optellen bij het eerste cijfer dat
je hebt opgeslagen. In je geheugen staat nu 6 (5+1) en 2. Je kan nu beide cijfers van
elkaar aftrekken en dat resultaat ook onthouden. In je geheugen staat nu, 6, 2 en 4.
Dit hele proces van opslaan, bewerken en terug opslaan is gelijkaardig aan wat een
computer kan doen met twee cijfers. Het ganse proces kan als volgt in C++ worden
uitgedrukt
a = 5;
b = 2;
a = a + 1;
result = a – b;

Dit is een heel eenvoudig voorbeeld met twee gehele getallen (integers). Bedenk dat een
computer duizenden cijfers en getallen kan opslaan en de meest ingewikkelde
wiskundige bewerkingen kan uitvoeren. Daarom kunnen we een gedeelte van het
geheugen reserveren voor een variabele (cijfer, getal, tekst, etc.) en er een bepaalde
inhoud in opslaan.
Elke variabele heeft een unieke naam (identifier) nodig. In het stukje code hierboven zijn
a, b en result de namen van de verschillende variabelen. We hadden net zo goed een
andere naam kunnen verzinnen, zolang deze maar een geldige naam is.

3.2 Identifiers
Een geldige naam (identifier) voor een variabele bestaat uit letters, cijfers of _ karakters.
Spaties of andere symbolen zijn niet toegelaten. Bovendien dient een naam met een
letter te beginnen maar in uitzonderlijke gevallen kan een naam ook met een _ beginnen.
Bijkomende voorwaarde is dat je bij het verzinnen van je namen rekening moet houden
met het feit dat een naam geen door C++ of je compiler voorbehouden woord kan zijn.
Deze noemt men reserved keywords.
Op de volgende bladzijde vind je een lijst met voorbehouden woorden.

8 Programmeren in C++ - ing. Roger D’Joos

 Variabelen en datatypes

De standaard gereserveerde woorden zijn:

asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default,
delete,
do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend,
goto,
if, inline, int, long, mutable, namespace, new, operator, private, protected, public,
register,
reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch,
template,
this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void,
volatile, wchar_t, while

Het is best mogelijk dat je compiler buiten deze lijst nog meer gereserveerde woorden
heeft.
Let op: C++ is wat men noemt een “case sensitive language”. Een naam in hoofdletters is
niet dezelfde als een naam in kleine letters. Zo is bijvoorbeeld RESULTAAT niet hetzelfde
als Resultaat of resultaat.

3.3 Data types

Gegevens of data zijn een onderdeel van een computerprogramma en worden
opgeslagen in het geheugen. Om deze gegevens zo efficiënt mogelijk op te slaan, dient de
computer te weten wat voor soort gegevens dit zijn. Het opslaan van een cijfer vraagt
minder geheugen dan het opslaan van een karakter of een groot getal.
Een computergeheugen is onderverdeeld in bytes. Een byte (8bits) is het minimum aan
geheugen dat we kunnen beheren en aanspreken in C++. In een byte kunnen we een
karakter opslaan of een geheel getal tussen 0 en 255. Maar een computer kan ook met
complexere gegevens omgaan door verschillende bytes samen te nemen. Op de volgende
bladzijde vind je een lijst met de meest voorkomende datatypes.

Programmeren in C++ - ing. Roger D’Joos 9

Variabelen en datatypes

Naam Omschrijving Grootte* Bereik*

char Karakter of klein 1 byte Met tekenbit (signed): -128 tot

(geheel) getal 127
Zonder tekenbit (unsigned): 0 tot
255

short int (short) Kort (geheel) 2 bytes Met tekenbit: -32768 tot 32767
getal Zonder tekenbit: 0 tot 65535

int (Geheel) getal 4 bytes Met tekenbit: -2147483648 tot

2147483647
Zonder tekenbit: 0 tot
4294967295

long int (long) Lang getal 4 bytes Met tekenbit: -2147483648 tot
2147483647
Zonder tekenbit: 0 tot
4294967295

bool Booleaanse 1 byte True of False

variabele

float Niet geheel getal 4 bytes ±3.4±38 (~7digits)

double Niet geheel getal 8 bytes ±1.7±308 (~15 digits)

long double Niet geheel getal 8 bytes ±1.7±308 (~15 digits)

wchar_t Karakter 2 bytes 16 bit karakter

*de waarde in de kolommen Grootte en Bereik zijn afhankelijk van het

besturingssysteem waarvoor het programma is gecompileerd. De waarden die je
hierboven vindt zijn van toepassing voor de meeste 32-bit systemen.

3.4 Declaratie van variabelen

Voor je een variabele kan gebruiken in C++ moet je eerst aangeven tot welk soort
datatype deze behoort. De correcte wijze om een variabele te declareren is: eerst het
gewenste datatype, daarna de naam. Bijvoorbeeld:
int a;
float mijn_getal;

De eerste lijn creëert een variabele van het type integer met als naam a, de tweede lijn
creëert een variabele van het type float met als naam mijn_getal.

10 Programmeren in C++ - ing. Roger D’Joos

 Variabelen en datatypes

Eenmaal gedeclareerd kan een variabele in het programma worden gebruikt.

Wanneer je meerdere variabelen van hetzelfde type wil gaan gebruiken kan je deze in
één enkele instructie declareren door hun namen met een komma te scheiden.
Bijvoorbeeld:
int a, b, c;

Hier worden drie variabelen: a, b en c van het datatype int gedeclareerd en heeft
dezelfde betekenis als:
int a;
int b;
int c;

De data types char, short, long en int kunnen signed of unsigned zijn, afhankelijk van
het bereik dat we willen gebruiken. Een signed datatype kan positieve en negatieve
getallen weergeven, een unsigned datatype enkel positieve getallen, nul inbegrepen.
Het gebruik van deze datatypes kan worden gespecificeerd door voor de naam signed of
unsigned te vermelden. Bijvoorbeeld:
unsigned short int NumberOfSisters;
signed int MyBalance;

Wanneer we een variabele niet expliciet als signed of unsigned declareren, zullen de
meeste compilers het data type automatisch als signed declareren. In het voorgaande
voorbeeld hadden we dus mogen schrijven:
int MyBalance;

De data types short en long kunnen zonder verdere specificatie worden gebruikt. Zij
verwijzen automatisch naar gehele getallen int. Volgende declaraties hebben dezelfde
betekenis:
short Year;
short int Year;

Het programma op de volgende bladzijde toont ons de verschillende declaraties.

Programmeren in C++ - ing. Roger D’Joos 11

Variabelen en datatypes

// operating with variables 4

#include <iostream>
using namespace std;
int main ()
{
// declaring variables:
int a, b;
int result;
// process:
a = 5;
b = 2;
a = a + 1;
result = a - b;
// print out the result:
cout << result;
// terminate the program:
return 0;
}

3.5 Globale en lokale variabelen

Elke variabele die we in een programma wensen te gebruiken moet eerst worden
gedeclareerd. In het vorige voorbeeld hebben we dit gedaan aan het begin van het
hoofdprogramma.
Een variabele kan globaal of lokaal zijn. Een globale variabele wordt gedeclareerd bij
het begin van een programma, voor het begin van het hoofdprogramma en voor het
begin van eventuele functies.
Een lokale variabele wordt binnen het hoofdprogramma of binnen een functie
gedeclareerd.
Een globale variabele is beschikbaar binnen het ganse programma, ook binnen functies,
terwijl een lokale variabele enkel beschikbaar is het blok (tussen {}) waar ze is
gedeclareerd.
Op de volgende bladzijde vindt je een voorbeeld.

12 Programmeren in C++ - ing. Roger D’Joos

 Variabelen en datatypes

Een voorbeeld:
//globale en lokale variabelen
#include <iostream>
using namespace std;
//declaratie van globale variabelen
int Integer;
char aCharacter;
char String [20];
unsigned int NumberOf;
int main ()
{
unsigned short Age; //lokale variabele
float aNumber, AnotherOne; //lokale variabelen
cout<< ”Uw Leeftijd? ”;
cin>>Age;
…
}

In het voorbeeld kunnen de variabelen Integer, aCharacter en String overal in het

programma worden gebruikt. De variabelen Age, aNumber en AnotherOne kunnen enkel
binnen het hoofdprogramma worden gebruikt.

3.6 Initialisatie van variabelen

Bij de declaratie van een lokale variabele is de waarde ervan onbepaald. Indien men bij
de declaratie een bepaalde waarde wil toekennen aan een variabele, dan kan dit op twee
manieren.
De eerste manier, de c-like manier, gaat als volgt:
Data type Naam = initiële waarde;

Bijvoorbeeld: de variabele a dient op het ogenblik dat ze wordt gedeclareerd de waarde

0 te krijgen:
int a = 0;

De tweede manier, constructor initialization, gaat als volgt:

Data type Naam (initiële waarde);

int a(0);

Beide technieken kunnen binnen C++ worden gebruikt.

Een voorbeeld vindt je op de volgende bladzijde.

Programmeren in C++ - ing. Roger D’Joos 13

Variabelen en datatypes

// initialization of variables 6
#include <iostream>
using namespace std;

int main ()
{
int a=5; // initial value = 5
int b(2); // initial value = 2
int result; // initial value undetermined

a = a + 3;
result = a - b;
cout << result;

return 0;
}

3.7 Strings
Een variabele die niet numerieke waarden langer dan één karakter bevat, is een string.
Omdat het data type string geen fundamenteel type is, moet de C++ bibliotheek string
aan het programma worden toegevoegd.
// my first string This is a string
#include <iostream>
#include <string>
using namespace std;

int main ()
{
string mystring = "This is a string";
cout << mystring;
return 0;
}

Volgende initialisatie is geldig:

string myString = “Dit is een string variabele”;
string myString (“Dit is een string variabele”);

Net zoals alle andere basis C++ variabelen hoeft een string geen initiële waarde te
krijgen bij de declaratie, ook kan tijdens de uitvoering van het programma een waarde
worden toegewezen.

14 Programmeren in C++ - ing. Roger D’Joos

 Variabelen en datatypes

3.8 Constanten
Een constante is een uitdrukking met een vaste waarde.

3.8.1 Werkelijke gegevens (literals)

Een literal wordt gebruikt om een waarde toe te kennen binnen een programma. We
hebben deze al eerder gebruikt om een waarde toe te kennen aan een variabele of om
iets uit te drukken:
a = 5;
myString (“This is a string”);
cout << myString;

Literals kunnen worden opgedeeld in gehele waarden (integer numerals), rationele

waarden (floating point numerals), karakters (characters), character strings of kortweg
strings en booleaanse waarden (boolean values).

3.8.1.1 Gehele waarden

1776;
707;
-123;

Deze stellen gehele getallen voor. Om een getalwaarde voor te stellen hoeven we geen
aanhalingstekens (“) of andere karakters te gebruiken. Er kan ook geen twijfel over
bestaan dat dit een constante waarde is.
Buiten de getallen uit het decimale talstelsel, kunnen met C++ ook getallen uit het octale
talstelsel (grondtal 8) en het hexadecimale talstelsel (grondtal 16) worden gebruikt.
Om een octaal getal uit te drukken dient voor het getal een 0 te worden geplaatst. Bij een
hexadecimaal getal dient voor het getal 0x te worden geplaatst.
Voorbeeld:
75 //decimaal
0113 //octaal
0x4b // hexadecimaal

Hier wordt driemaal hetzelfde getal voorgesteld, namelijk 75.

Ook werkelijke waarden (literals) moeten tot een bepaald datatype behoren. Standaard
behoren gehele waarden tot het datatype int maar we kunnen ze ook unsigned (door het
achtervoegsel u te gebruiken) of long (door het achtervoegsel l te gebruiken) maken.
Voorbeeld:
75 //int
75u //unsigned int
75l //long
75ul //unsigned long

Voor het achtervoegsel kunnen zowel hoofd- als kleine letters worden gebruikt.

Programmeren in C++ - ing. Roger D’Joos 15

Variabelen en datatypes

3.8.1.2 Reële waarden (floating point numbers)

Deze stellen getallen met cijfers na de komma en/of exponenten voor.
Voorbeeld:
3.14159 //3.14159
23
6.02e23 //6.02*10
-19
1.6e-19 //1.6*10
3.0 //3.0

Dit zijn reële getallen. Het eerste is PI, het tweede is het getal van Avogrado, het derde is
de elektrische lading van een elektron en het laatste is gewoon het cijfer 3 in reële
notatie.
Het standaardtype voor reële getallen is double maar we kunnen er ook een ander
datatype aan toekennen, bijvoorbeeld float of long double. Dit kan door achter het
getal de letter f of l te plaatsen.
Voorbeeld:
3.14159l //long
6.02e23f //float

Elke letter die tot een reëel getal behoort (e, f of l) kan zowel als hoofd- of kleine letter
worden geschreven.

3.8.1.3 Karakter- en string constanten

Er bestaan ook niet numerieke constanten:
‘z’
‘p’
“Hello World”
“Hoe maakt u het?”

De twee eerste lijnen stellen karakters voor, de twee laatste een string van karakters.
Het valt je meteen op dat om een enkel karakter voor te stellen enkele aanhalingstekens
(‘) worden gebruikt, om een string voor te stellen worden dubbele aanhalingstekens (“)
gebruikt.
Bij het gebruik van karakters en strings dient men er steeds op toe te zien om
aanhalingstekens te gebruiken. Om die manier kan het onderscheid worden gemaakt
met een variabele of een gereserveerd woord.
Voorbeeld:
x
‘x’

In het voorbeeld verwijst x naar een variabele met de naam x, terwijl ‘x’ verwijst naar
het karakter x.

16 Programmeren in C++ - ing. Roger D’Joos

 Variabelen en datatypes

Er zijn bij de karakter- en string constanten een paar buitenbeentjes: de escape codes.
Deze hebben een speciale betekenis en het is moeilijk om deze in de broncode op een
andere manier weer te geven.
Een paar voorbeelden: een tabpositie of een nieuwe lijn. Om het onderscheid te maken
tussen een karakter en een escape code worden escape codes steeds vooraf gegaan door
een back slash \.
Een lijst met vaak gebruikte escape codes:

\n newline

\r carriage return

\t tab

\v vertical tab

\b backspace

\f form feed

\a alert (beep)

\’ single quote (‘)

\” double quote (“)

\? question mark (?)

\\ backslash (\)

Bijvoorbeeld:

‘\n’

‘\t’

“Left \t Right”

“one\ntwo\nthree”

Bovendien kan op deze manier eender welk karakter door middel van zijn ASCII-waarde
(zie cursus Digitale elektronica 3ELEA) op het scherm worden geplaatst. De ASCII-
waarde dient echter als octaal of hexadecimaal getal te worden uitgedrukt. Bv: \23
In het eerste geval moet de \ onmiddellijk worden gevolgd door het octaal getal. In het
tweede geval moet de \ worden gevolgd door een x met daarna het hexadecimale getal.
Bv: \x23

Programmeren in C++ - ing. Roger D’Joos 17

Variabelen en datatypes

Een string constante kan over meer dan één lijn broncode worden gespreid door op het
einde van de lijn een backslash (\) te plaatsen.

“Een string gespreid over\

twee lijnen.”

Verschillende strings kunnen worden samengevoegd door ze te scheiden door één of

meerdere spaties, tabs of eender welk ander geldig blanco karakter.

“Dit vormt één” “enkele” “string van” “karakters”

3.8.1.4 Booleaanse constanten

Er zijn slechts twee geldige Booleaanse waarden, namelijk true en false. In C++ kunnen
zij worden weergegeven als waarden van het data type bool.

3.8.2 Gedefinieerde constanten

C++ biedt de mogelijkheid om constanten te benoemen naar willekeur door gebruik te
maken van de preprocessor directive #define.
De declaratie gebeurt als volgt:
#define naam waarde

Bijvoorbeeld:
#define PI 3.14159
#define NEWLINE ‘\n’

Dit definieert twee nieuwe constanten, PI en NEWLINE. Eenmaal gedefinieerd, kunnen

ze, net zoals elke andere constante in de broncode worden opgenomen. Een voorbeeld:
/* gedefinieerde constanten: Programma om cirkelomtrek te 31.4159
berekenen */
#include <iostream>
using namespace std;
#define PI 3.14159
#define NEWLINE '\n'
int main ()
{
double r=5.0; // radius
double circle;
circle = 2 * PI * r;
cout << circle;
cout << NEWLINE;
return 0;
}

18 Programmeren in C++ - ing. Roger D’Joos

 Variabelen en datatypes

De preprocessor zal, wanneer hij #define tegenkomt in de broncode, de naam van de

constante, PI en NEWLINE in dit geval, vervangen door 3.14159 en ‘\n’.

3.8.2.1 Gedeclareerde constanten

Met het voorvoegsel const kunnen, net zoals met alle andere variabelen, constanten van
een bepaald datatype worden gedeclareerd:

const int breedte = 100;

const char tabulator = ‘\t’;

In dit voorbeeld zijn breedte en tabulator constanten van respectievelijk het int type en
het char type. Ze worden door de compiler behandeld net zoals alle andere variabelen.
Enkel de waarde kan niet worden gewijzigd.

Programmeren in C++ - ing. Roger D’Joos 19

Operators (bewerkingen)

4 Operators (bewerkingen)
4.1 Inleiding
We kennen variabelen en constanten, we kunnen met beide datatypes bewerkingen
gaan uitvoeren. In tegenstelling tot andere programmeertalen gebruikt C++ vaak tekens
en karakters die geen deel uitmaken van het alfabet maar die toch op ons toetsenbord
aanwezig zijn. Voordeel is dat C++ minder gebruik maakt van bestaande (Engelse)
woorden.

4.2 Assignment (= toekenning)

Deze operator kent een bepaalde waarde toe aan een variabele.

a = 5;

Deze instructie kent de waarde 5 toe aan de variabele a. De toekenning gebeurt steeds
van links naar rechts en nooit andersom!

a = b;

Bovenstaande instructie kent de waarde opgeslagen in de variabele b toe aan variabele

a.
Laten we even kijken wat er in de volgende code gebeurt. De evolutie van de inhoud van
de verschillende variabelen staat in de commentaar.
// assignment operator a:4 b:7

#include <iostream>
using namespace std;

int main ()
{
int a, b; // a:?, b:?
a = 10; // a:10, b:?
b = 4; // a:10, b:4
a = b; // a:4, b:4
b = 7; // a:4, b:7

cout << "a:";

cout << a;
cout << " b:";
cout << b;

return 0;
}

20 Programmeren in C++ - ing. Roger D’Joos

 Operators (bewerkingen)

Deze code geeft als resultaat dat de waarde van a = 4 en de waarde van b = 7. Merk op
dat de waarde van a niet beïnvloed werd door de waarde van b, ondanks het feit dat we
eerder a = b hebben gesteld (van links naar rechts regel!).
In bovenstaande declaraties is a = lvalue en b = rvalue.
Een voordeel dat C++ heeft ten opzichte van andere programmeertalen is dat een
toewijzing kan worden gebruikt als de rvalue of een gedeelte van de rvalue bij een
volgende toewijzing. Voorbeeld:

a = 2 + (b = 5);

Dit is equivalent aan:

b = 5;
a = 2 + b;

In mensentaal: ken de waarde 5 toe aan variabele b, ken daarna de waarde 2 toe aan
variabele a, vermeerderd met de waarde van de vorige toewijzing. Dit betekent: a = 7.
Volgende uitdrukking is eveneens geldig in C++

a = b = c = 5;

Dit kent aan variabelen a, b en c de waarde 5 toe.

4.3 Rekenkundige operatoren (+, -, *, /, %)

De vijf rekenkundige bewerkingen die door C++ worden ondersteund zijn:

+ optelling

- aftrekking

* vermenigvuldiging

/ deling

% modulo

Deze bewerkingen stemmen overeen met de bewerkingen uit de wiskunde. De enige

bewerking die je de wenkbrauwen kan doen fronsen is modulo, met operator %.
Modulo is de bewerking die als resultaat de rest van een deling geeft. Voorbeeld:

a = 11 % 3;

De variabele a zal de waarde 2 bevatten. 2 is immers de rest van de deling 11/3.

Programmeren in C++ - ing. Roger D’Joos 21

Operators (bewerkingen)

4.4 Samengestelde bewerkingen (+=, -=, *=, /=, >>=, <<=, &=, ^=, |=)
Wanneer we de waarde van een variabele willen wijzigen door een bewerking uit te
voeren op de huidige waarde van deze variabele kunnen we de zogenaamde
samengestelde bewerkingen gebruiken.

uitdrukking is gelijk aan

waarde += vermeerdering; waarde = waarde + vermeerdering;

a -= 5; a = a – 5;

a /= b a = a/b;

kostprijs *= eenheden +1; kostprijs = kostprijs * (eenheden+1);

Voorbeeld:
// compound assignment operators 5

#include <iostream>
using namespace std;

int main ()
{
int a, b=3;
a = b;
a+=2; // equivalent to a=a+2
cout << a;
return 0;
}

4.5 Vermeerderen en verminderen (increase, decrease) of (++, --)

De operatoren ++ en –– vermeerderen of verminderen de waarde van een variabele met
1. Ze zijn equivalent aan +=1 en -=1. Of:

c++;
c += 1;
c = c+1;

Dit betekent in feite hetzelfde. Deze uitdrukkingen vermeerderen de inhoud van

variabele c met 1.

22 Programmeren in C++ - ing. Roger D’Joos

 Operators (bewerkingen)

Een eigenschap van deze operator is dat we hem als voor- en als achtervoegsel kunnen
gebruiken. Met andere woorden, voor de variabele (++a) of na de variabele (a++).
Maar…in simpele bewerkingen zoals a++ of ++a heeft dit dezelfde betekenis, in andere
uitdrukkingen waarin het resultaat van deze bewerking wordt geëvalueerd, kan er een
verschil van betekenis ontstaan.
Even verduidelijken: in het geval van ++a wordt a vermeerderd voor het resultaat van
deze bewerking wordt geëvalueerd en verder wordt gebruikt. In het geval a++ wordt de
vermeerderde waarde pas in a opgeslagen na dat het resultaat van de bewerking is
geëvalueerd.
b=3; b=3;
a=++b: a=b++;
//a = 4 en b=4 //a = 3 en b = 4

In het voorbeeld links wordt b met 1 vermeerderd voor de waarde in a wordt

opgeslagen. In het voorbeeld rechts wordt de waarde van b naar a gekopieerd en daarna
wordt b met 1 vermeerderd.

4.6 Vergelijkende operatoren (==, !=, >, <, >=, <=)

Deze worden gebruikt om twee uitdrukkingen met elkaar te vergelijken. Het resultaat
van deze vergelijking is een Booleaanse waarde die enkel true of false kan zijn.
Een lijst van de mogelijke operatoren in C++:

== gelijk aan

!= niet gelijk aan

> groter dan

< kleiner dan

>= groter of gelijk aan

<= kleiner of gelijk aan

Een paar voorbeelden:

(7 == 5) //levert false op
(5 > 4) //levert true op
(3 != 2) //levert true op
(6 >= 6) //levert true op
(5 < 5) //levert false op

Programmeren in C++ - ing. Roger D’Joos 23

Operators (bewerkingen)

Vanzelfsprekend kunnen we deze bewerkingen niet enkel toepassen op constanten

maar op elke valabele uitdrukking, inclusief variabelen.
Stel dat a = 2, b = 3 en c = 6.

(a == 5) //levert false op daar a niet gelijk is aan 5.

(a * b >= c) //levert true op daar a *b = c
(b+4 > a*c) //levert false op daar 3 + 4 niet groter is dan 2 * 6
((b = 2) == a) //levert true op

Let op! De operator = (één gelijkheidsteken) is n iet hetzelfde als == (twee

gelijkheidstekens). De eerste is een toekenning (assignment) en kent de waarde rechts
van het gelijkheidsteken toe aan de variabele links van het gelijkheidsteken, de tweede
is een vergelijkende operator die kijkt of beide uitdrukkingen links en rechts aan elkaar
gelijk zijn.
In de laatste uitdrukking kennen we eerste de waarde 2 toe aan variabele b en
vergelijken deze dan met variabele a.

4.7 Logische operatoren (logical operators) !, &&, ||

De operator ! is de C++ operator die de Booleaanse operatie NOT uitvoert. Deze operatie
keert de waarde van de (logische) uitdrukking om. Dus: true wordt false en omgekeerd.

!(5 == 5) // evaluates to false because the expression (5 == 5) is true.

!(6 <= 4) // evaluates to true because (6 <= 4) would be false.
!true // evaluates to false

!false // evaluates to true.

De logische operatoren && en || evalueren steeds twee uitdrukkingen. De operator &&

staat voor de Booleaanse operatie EN (AND), de operator || staat dan weer voor de
Booleaanse operatie OF (OR).

a b a && b

false false false

false true false

true false false

true true true

24 Programmeren in C++ - ing. Roger D’Joos

 Operators (bewerkingen)

a b a || b

false false false

false true true

true false true

true true true

( (5 == 5) && (3 > 6) ) // levert false (true && false)

( (5 == 5) || (3 > 6) ) // levert true (true || false)

4.8 Voorwaardelijke operator

De conditionele operator evalueert een uitdrukking en levert een bepaalde waarde op
wanneer de uitdrukking waar is en een andere waarde wanneer de uitdrukking false is.
Het formaat van deze uitdrukking:
Voorwaarde? waarde 1: waarde 2

Wanneer aan de voorwaarde is voldaan, levert de uitdrukking waarde 1 op, is niet aan
de voorwaarde voldaan dan levert de uitdrukking waarde 2 op.

7 == 5 ? 4 : 3 // levert 3, daar 7 niet gelijk is aan 5.

7== 5 + 2 ? 4 : 3 // levert 4, daar 7 gelijk is aan 5+2.
5 > 3 ? a : b // levert a, daar 5 groter is dan 3.
a > b ? a : b // levert het grootste resultaat op, a of b.

// voorwaardelijke operator 7
#include <iostream>
using namespace std;
int main ()
{
int a, b, c;
a = 2 : b = 7;
c = (a > b) ? a : b;
cout << c;
return 0
}

Programmeren in C++ - ing. Roger D’Joos 25

Operators (bewerkingen)

In het voorbeeld is a gelijk aan 2 en b gelijk aan 7. De evaluatie a > b levert false op zodat
het resultaat gelijk is aan 7.

26 Programmeren in C++ - ing. Roger D’Joos

 Basis in- en uitvoer

5 Basis in- en uitvoer

5.1 Inleiding
Bij de eerder gebruikte voorbeeldprogramma’s was er weinig interactie met de
gebruiker. Met de standaard in- en uitvoerbibliotheek is communicatie met de gebruiker
mogelijk door boodschappen op het scherm te plaatsen en gegevens van het toetsenbord
in te lezen.
Om in- en uitvoer naar sequentiële media zoals scherm en toetsenbord te realiseren
gebruikt C++ streams. Dit is een object waar men karakters aan kan toevoegen of van
wegnemen zonder iets over de fysische eigenschappen of de werking te weten.
De C++ bibliotheek bevat het standaardbestand <iostream>, waarin alle in- en uitvoer
objecten zijn gedeclareerd.

5.2 Standaard uitvoer (cout)

De standaard uitvoer van een programma is het computerscherm, het C++ object dat
deze operatie uitvoert is cout.
De opdracht cout wordt steeds samen met de invoegoperator << gebruikt!
cout << “Uitvoerregel”; // toont Uitvoerregel op het scherm
cout << 120; // toont 120 op het scherm
cout << x; // toont de waarde van variabele x op het scherm

De << operator voegt de gegevens die er op volgen in de stream cout. In de voorbeelden

hierboven zijn achtereenvolgens de constante “uitvoerregel”, het getal 120 en de waarde
van de variabele x aan de stream toegevoegd. Wanneer we karakters gebruiken moeten
we deze steeds tussen aanhalingstekens plaatsen. Volgende uitdrukkingen hebben een
totaal andere betekenis.

cout << “Hallo”; // toont Hallo op het scherm

cout << Hallo; // toont de inhoud van variabele Hallo

De operator << mag meer dan eens in één instructie (statement of programmalijn)
worden gebruikt.

cout << “Hallo, “ << “ik ben ” << “een C++ uitdrukking.”;

De laatste instructie toont Hallo, ik ben een C++ uitdrukking op het scherm.

Programmeren in C++ - ing. Roger D’Joos 27

Basis in- en uitvoer

Een combinatie van karakters en variabelen of meer dan één variabele kunnen op deze
manier op het scherm worden getoond.

cout << “Hallo, ik ben “, << leeftijd << “jaar oud en mijn postnummer is “ << postcode

Wanneer we er van uitgaan dat de variabele leeftijd = 24 en de variabele postcode =

2000, dan zal de uitvoer als volgt zijn:
Hallo, ik ben 24 jaar oud en mijn postnummer is 2000

Belangrijk om weten is dat cout na uitvoering niet automatisch naar het begin van een
nieuwe lijn gaat.

cout << “Dit is een zin. ”;

cout << “En dit is de volgende zin. “;

Bovenstaande statements geven het volgende resultaat:

Dit is een zin. En dit is de volgende zin.

Wanneer we aan het begin van een nieuwe lijn willen starten, dan moeten we dit
expliciet vermelden in de statements. In C++ kennen we \n (backslash n) als de
uitdrukking die zegt om aan een nieuwe lijn te beginnen.

De statements

cout << “Eerste lijn. “\n;

cout << “Volgende lijn. \nLaatste lijn.”;

Hebben als resultaat:

Eerste lijn.
Volgende lijn.
Laatste lijn.

Om een nieuwe lijn te beginnen kan men ook endl gebruiken.

cout << “Eerste lijn .” << endl;

cout << “Volgende lijn. “; endl;

28 Programmeren in C++ - ing. Roger D’Joos

 Basis in- en uitvoer

Heeft als resultaat:

Eerste lijn.
Volgende lijn.

5.3 Standaard invoer (cin)

Zeer vaak worden gegevens ingevoerd via het toetsenbord. In C++ gebeurt dit met het
object cin gevolgd door de extractieoperator >>. De operator wordt steeds gevolgd door
de naam van de variabele waarin men de invoer wil opslaan.

int leeftijd;
cin >> leeftijd;

Het eerste statement declareert een variabele van het type integer met als naam leeftijd.
Het tweede statement wacht op invoer via het toetsenbord.
Cin kan de invoer pas verwerken wanneer op de “Return”- of “Enter”- toets wordt
gedrukt.

// voorbeeldprogramma invoer/uitvoer Geef een geheel getal: 235

Het ingevoerde getal is: 235 en het
#include <iostream> dubbele hiervan is: 470.
using namespace std;

int main ()
{
int i;
cout << "Geef een geheel getal: ";
cin >> i;
cout << "Het ingevoerde getal is: " << i;
cout << " en het dubbele hiervan is: " << i*2
<< ".\n";
return 0;
}

De gebruiker van een computerprogramma ligt zeer vaak aan de basis van optredende
fouten, zelfs in een relatief eenvoudig programma zoals dat hierboven. Er wordt een
geheel getal verwacht maar stel dat de gebruiker een naam (string) ingeeft. Resultaat:
een foutmelding! Later zullen we zien dat we dit kunnen omzeilen.

Programmeren in C++ - ing. Roger D’Joos 29

Basis in- en uitvoer

Het kan ook voorkomen dat wordt gevraagd om meer dan één gegeven tegelijkertijd in
te voeren.

int a, b;
cin >> a >> b;
/* dit is hetzelfde als
cin >> a;
cin >> b
*/

De gebruiker dient hier twee waarden in te voeren, één waarde voor variabele a en één
waarde voor variabele b. Beide waarden worden gescheiden door één van volgende
blanco karakters: een spatie, een TAB of een nieuwe lijn \n.

5.4 Cin en strings

We kunnen cin ook gebruiken om strings in te lezen.

cin >> mijnstring;

Maar, zoals reeds eerder gezegd, wordt de invoer gestopt wanneer een blanco karakter
in de string voorkomt. Soms nuttig maar vaak erg vervelend, vooral wanneer
bijvoorbeeld een hele zin moet worden ingelezen.
Dit kunnen we omzeilen door de functie getline te gebruiken.

// Invoer van karakterstrings met cin What's your name? Kris Kras
#include <iostream> Hallo Kris Kras.
#include <string>
Wat is uw favoriete voetbalploeg? ‘t
using namespace std; Hoekske
Ik vind ‘t Hoekske ook goed!
int main ()
{
string mystr;
cout << "Wat is uw naam? ";
getline (cin, mijnstring);
cout << "Hallo " << mijnstring << ".\n";
cout << "Wat is uw favoriete voetbalploeg? ";
getline (cin, mijnstring);
cout << "Ik vind " << mijnstring << " ook
goed!\n";
return 0;
}

30 Programmeren in C++ - ing. Roger D’Joos

 Basis in- en uitvoer

In beide gevallen is dezelfde variabele, mijnstring, gebruikt. Bij de tweede aanroep is de

eerdere inhoud gewoon overschreven.

5.5 Stringstream
Het standaardbestand sstream bevat een functie stringstream. Deze laat ons toe om op
een eenvoudige manier karakters in of uit strings te halen. Dit is bijzonder handig
wanneer men karakters naar een getalwaarde wenst te converteren of omgekeerd. Een
voorbeeld: we wensen een getalwaarde uit een string te halen.

string mijnstr ("1204"); // declarative van een stringvariabele met als inhoud 1204
int mijnint; // declaratie van een variabele van het type integer
stringstream(mijnstr) >> mijnint; // de inhoud van mijnstr wordt omgezet naar een getalwaarde
// en in de variabele mijnint geplaatst.

// voorbeeld met stringstreams Geef de prijs: 22.25

#include <iostream> Geef de hoeveelheid: 7
#include <string>
Totale kostprijs: 155.75
#include <sstream>
using namespace std;

int main ()
{
string mijnstr;
float prijs = 0;
int aantal = 0;

cout << "Geef de prijs: ";

getline (cin,mijnstr);
stringstream(mijnstr) >> prijs;
cout << "Geef de hoeveelheid: ";
getline (cin,mijnstr);
stringstream(mijnstr) >> aantal;
cout << "Totale kostprijs: " << prijs * aantal
<<
endl;
return 0;
}

In dit voorbeeld dienen we een aantal numerieke waarden (prijs en aantal) in te voeren.
In plaats van deze als getallen in te voeren, worden ze als karakterstrings ingelezen. Met
behulp van stringstream worden ze daarna omgevormd en in de respectievelijke
variabelen geplaatst.

Programmeren in C++ - ing. Roger D’Joos 31

Basis in- en uitvoer

Door deze methode toe te passen hebben we meer controle over wat er met de invoer
van numerieke waarden, getallen dus, gebeurt. Het ingeven door de gebruiker en de
interpretatie door de computer zijn nu volledig van elkaar gescheiden. Deze methode
wordt dan ook toegepast wanneer veel numerieke waarden dienen te worden ingevoerd
door de gebruiker.

32 Programmeren in C++ - ing. Roger D’Joos

 Controlestructuren

6 Controlestructuren
6.1 Inleiding
De opbouw van een programma blijft meestal niet beperkt tot een sequentie van
instructies. Zo kunnen bepaalde programmaonderdelen worden herhaald, beslissingen
worden genomen, etc. Om deze redenen beschikt C++ over een aantal
controlestructuren om dit mogelijk te maken.
Met de invoer van deze controlestructuren dienen we een nieuw concept in te voeren:
de samengestelde instructie of blok. Dit is een groep van instructies gescheiden door ;
(net zoals alle C++ instructie) maar gegroepeerd in een blok omgeven door accolades { }.
{ instructie 1; instructie 2; instructie 3}

De meeste van deze controlestructuren bestaan uit een eenvoudige of een

samengestelde instructie. In het eerste geval hoeven we geen accolades te gebruiken, in
het tweede geval wel.

6.2 Conditionele structuur (if else)

Het gereserveerde woord if wordt gebruikt om een instructie of een samengesteld
instructie uit te voeren wanneer aan een bepaalde voorwaarde is voldaan.
If (voorwaarde) instructie

Hierin is voorwaarde de uitdrukking die wordt geëvalueerd. Wordt aan de voorwaarde

voldaan, dan wordt de instructie uitgevoerd. Is niet aan de voorwaarde voldaan, dan
wordt de instructie genegeerd en gaat het programma naar de volgende instructie. Een
voorbeeld: het programma toont x is gelijk aan 100 wanneer de inhoud van x ook
gelijk is aan 100.

If (x == 100)
cout << “x is gelijk aan 100”;

Willen we meer dan één instructie uitvoeren wanneer aan een voorwaarde is voldaan,
dan gebruiken we een blok of samengestelde instructie.

If (x == 100)
{
Cout << “x is “;
Cout << x;
}

Programmeren in C++ - ing. Roger D’Joos 33

Controlestructuren

We kunnen ook specificeren wat er moet gebeuren wanneer niet aan de voorwaarde is
voldaan. Dit doen we door het gereserveerde woord else te gebruiken.
If (voorwaarde) instructie 1 else instructie 2

Een voorbeeld:

if (x ==100)
cout << “x is gelijk aan 100”;
else
cout << “x is niet gelijk aan 100”;

De if else structuur kan worden toegepast om bijvoorbeeld een reeks getalwaarden te

controleren. Het volgende voorbeeld controleert of de waarde van x positief of negatief
is of gelijk is aan nul.

if (x > 0)
cout << "x is positief";
else if (x < 0)
cout << "x is negatief";
else
cout << "x is gelijk aan 0";

Niet vergeten: meer dan één instructie…tussen accolades plaatsen!

6.3 Iteraties (herhalingsopdrachten, lussen of loops)

In een iteratie wordt een bepaalde instructie of een reeks instructies een aantal keer
herhaald of uitgevoerd zolang aan een voorwaarde is voldaan.

6.3.1 While loop

While (uitdrukking) instructie

Hier wordt de instructie herhaald zolang aan de uitdrukking is voldaan. Een voorbeeld
vindt u op volgende bladzijde:

34 Programmeren in C++ - ing. Roger D’Joos

 Controlestructuren

// programma countdown met while Geef het begincijfer: 8

8, 7, 6, 5, 4, 3, 2, 1, FIRE!
#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Geef het begincijfer: ";
cin >> n;

while (n>0)
{
cout << n << ", ";
--n;
}

cout << "FIRE!\n";

return 0;
}

Bij de start van het programma wordt de gebruiker gevraagd om het getal in te geven
van waar de aftelling moet beginnen. Het blok tussen de accolades wordt herhaald
zolang aan de voorwaarde n > 0 wordt voldaan.
Bij het maken van een while loop moeten we rekening houden met het feit dat deze
eindig moet zijn, er moet een ogenblik zijn waarop niet langer aan de gestelde
voorwaarde wordt voldaan. Gebeurt dit niet dan zal de while lus oneindig lang duren. In
het voorbeeld hebben we er voor gezorgd dat telkens de lus wordt doorlopen de
variabele n met 1 wordt verminderd. Wanneer n gelijk wordt aan nul, is niet langer aan
de voorwaarde voldaan en zal de lus eindigen.

6.3.2 Do – while loop

do instructie while (voorwaarde);

Er is geen verschil in functionaliteit met de vorige instructie, behalve dat nu de

voorwaarde wordt getest na het uitvoeren van de instructie(s). Dit betekent dat de
instructie(s), in tegenstelling tot de while lus, minstens één keer worden uitgevoerd,
zelfs wanneer niet aan de voorwaarde is voldaan.
Het voorbeeld op de volgende bladzijde illustreert de do – while loop.

Programmeren in C++ - ing. Roger D’Joos 35

Controlestructuren

// voorbeeld do - while Geef een getal (0 om te eindigen):

12345
#include <iostream> U hebt ingevoerd: 12345
using namespace std; Geef een getal (0 om te eindigen):
160277
int main () U hebt ingevoerd: 160277
{ Geef een getal (0 om te eindigen): 0
unsigned long n;
U hebt ingevoerd: 0
do
{
cout << "Geef een getal (0 om te eindigen):
";
cin >> n;
cout << "U hebt ingevoerd: " << n << "\n";
}
while (n != 0);
return 0;
}

6.3.3 De for loop

for (beginvoorwaarde; voorwaarde; stap) instructie

Ook hier wordt een instructie herhaald zolang aan een voorwaarde is voldaan. In
tegenstelling tot de voorgaande herhalingsopdrachten waar niet exact was bepaald hoe
vaak deze werd doorlopen, is bij de for loop vooraf geweten hoe vaak hij wordt
uitgevoerd. Een voorbeeld:

// programma countdown met een for loop 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, FIRE!

#include <iostream>
using namespace std;
int main ()
{
for (int n=10; n>0; n--)
{
cout << n << ", ";
}
cout << "FIRE!\n";
return 0;
}

36 Programmeren in C++ - ing. Roger D’Joos

 Controlestructuren

Beginvoorwaarde en stap zijn optioneel, we hoeven niets in te vullen maar de

kommapunt moet steeds worden gebruikt! We zouden bijvoorbeeld kunnen schrijven:
For (;n < 10;) wanneer we geen beginvoorwaarde of stap wensen. Of for (;n < 10; n++)
wanneer we wel een stap maar geen beginvoorwaarde willen (beginvoorwaarde is
misschien eerder al gedeclareerd).
Bovendien is het mogelijk om meer dan één uitdrukking in een bepaald veld gebruiken,
zij moeten dan wel worden gescheiden door een komma.

for ( n=0, i=100 ; n!=i ; n++, i.. )

{
// hier uw instructie(s)...
}

De loop wordt 50 maal uitgevoerd wanneer n noch i worden gewijzigd.

6.4 Sprong instructies

6.4.1 break instructie
Met deze instructie kunnen we een herhalingslus verlaten zelfs wanneer niet aan de
voorwaarde is voldaan.

// program break loop 10, 9, 8, 7, 6, 5, 4, 3, aftellen

gestopt!
#include <iostream>
using namespace std;

int main ()
{
int n;
for (n=10; n>0; n..)
{
cout << n << ", ";
if (n==3)
{
cout << "aftellen gestopt!";
break;
}
}
return 0;
}

Programmeren in C++ - ing. Roger D’Joos 37

Controlestructuren

6.4.2 continue instructie

Deze instructie maakt dat de huidige iteratie in een herhalingslus wordt verlaten, het
programma gaat verder met de volgende iteratie. In het volgende voorbeeld wordt 5 in
ons aftelprogramma overgeslagen.

// programma continue loop 10, 9, 8, 7, 6, 4, 3, 2, 1, FIRE!

#include <iostream>
using namespace std;

int main ()
{
for (int n=10; n>0; n..)
{
if (n==5) continue;
cout << n << ", ";
}
cout << "FIRE!\n";
return 0;
}

6.4.3 goto instructie

Goto laat ons toe om naar een bepaald punt in een programma te springen. Het punt
waar men naartoe wil wordt gemarkeerd met een label. Men zal bij het gebruik van deze
instructie de nodige voorzichtigheid aan de dag leggen want ze kan leiden tot foute
programma-uitvoering.
In gestructureerd- en/of object georiënteerd programmeren (OOP) wordt deze
instructie dan ook haast nooit gebruikt.

// programma goto loop 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, FIRE!

#include <iostream>
using namespace std;
int main ()
{
int n=10;
loop:
cout << n << ", ";
n..;
if (n>0) goto loop;
cout << "FIRE!\n";
return 0;
}

38 Programmeren in C++ - ing. Roger D’Joos

 Controlestructuren

6.5 Selectie structuur

6.5.1 Switch
Deze instructie is een beetje bijzonder. In een reeks constanten wordt naar een waarde
gezocht die overeenstemt met een bepaalde uitdrukking. Een beetje gelijkaardig met
wat we eerder in dit hoofdstuk met de if else structuur hebben gedaan. De structuur is
als volgt:
switch (uitdrukking)
{
case constant 1:
groep instructies 1;
break;
case constant 2:
groep instructies 2;
break;
.
.
.
default:
default groep instructies
}

De werking is als volgt: switch evalueert de uitdrukking en controleert of de waarde

gelijk is aan constante 1. Wanneer dit zo is, dan worden de instructies 1 uitgevoerd tot
de break instructie. Bij de break wordt de switch structuur verlaten.
Wanneer de uitdrukking niet gelijk was aan constante 1, dan wordt deze vergeleken met
constante 2. Zijn beiden gelijk aan elkaar, dan worden de instructies 2 uitgevoerd tot de
break instructie. Hier wordt de switch structuur verlaten.
Wanneer de uitdrukking aan geen enkele constante gelijk is (meer dan twee zijn
mogelijk!) dan kan men, optioneel een stukje standaardcode uitvoeren. Deze code komt
na het label default:
switch (x) if (x == 1)
{ cout << "x is 1";
case 1: else if (x == 2) {
cout << "x is 1"; cout << "x is 2";
break; else
case 2: cout << "value of x unknown";
cout << "x is 2";
break;
default:
cout << "value of x unknown";
}

Beide stukjes programmacode hebben hetzelfde resultaat.

Programmeren in C++ - ing. Roger D’Joos 39

Controlestructuren

Het bijzondere aan de switch structuur is dat er labels worden gebruikt in plaats van
samengestelde instructies of blokken. Dit maakt dat we na een groep instructies die
wordt uitgevoerd bij een bepaalde voorwaarde een break moeten gebruiken. Doen we
dit niet dan wordt alle code volgend aan de switch instructie uitgevoerd.

switch (x)
{
case 1:
case 2:
case 3:
cout << "x is 1, 2 or 3";
break;
default:
cout << "x is not 1, 2 nor 3";
}

De switch structuur kan enkel worden gebruikt om een bepaalde uitdrukking te

vergelijken met constanten! Daarom kunnen we geen variabele(n) gebruiken als labels,
bijvoorbeeld case n: waarin n een variabele is. Ook is case (1..3): niet toegelaten. Het
zijn geen geldige C++ constanten.
Wanneer men waarden of reeksen die geen constanten zijn wil vergelijken, dan gebruikt
men bij voorkeur een aaneenschakeling van if en else if instructies.

40 Programmeren in C++ - ing. Roger D’Joos

 Functies

7 Functies

Programmeren in C++ - ing. Roger D’Joos 41