|
Toekennen en Logisch vergelijken
Toekennen van gehele getallen
Bestudeer het programma TOEKENN.C om kennis te maken met toekenning
van waarden aan variabelen in C.
<![CDATA[
main ()
{
int a, b, c; /* integer variabelen t.b.v. voorbeelden */
a = 12; /* initialisatie */
b = 3;
c = a + b; /* 1 */
c = a - b; /* 1 */
c = a * b; /* 1 */
c = a / b; /* 1 */
c = a % b; /* 1 */
c = 12 * a + b / 2 - a * b * 2 / (a * c + b * 2); /* 2 */
c = c / 4 + 13 * (a + b) / 3 - a * b + 2 * a * a; /* 2 */
a = a + 1; /* 3 */
b = b * 5; /* 3 */
a = b = c = 20; /* 4 */
a = b = c = 12 * 13 / 4; /* 4 */
}
]]>
Er worden drie variabelen gedeclareerd, de rest van het programma is
niet veel meer dan een serie voorbeelden van een toekenning. De eerste
twee statements kennen een initi‰le waarde toe aan de variabelen
a en b. De volgende vijf statements (1) tonen de
vier basis reken funkties (som, verschil, produkt en quoti‰nt) en hoe
ze te gebruiken. De vijfde is de modulo funktie en geeft de rest bij
deling. Deze funkties kunnen alleen worden toegepast op variabelen
van het type int en char en de extensie's daarvan
long, short enz.
Dan volgen twee statements (2) die laten zien hoe een en ander
gecombineerd kan worden tot een complexe expressie. De daarop volgende
twee statements (3) dienen om een variabele met een bepaalde waarde te
verhogen. We zullen later in dit hoofdstuk zien hoe dat meer op een C
manier kan.
Het zal duidelijk zijn dat geen van de gegeven voorbeelden van enig nut
zijn.
Tenslotte blijven nog de laatste statements (4) over. Ze lijken in
eerste instantie misschien wat vreemd. De C compiler doorloopt de
toekenningen van rechts naar links (wij doen dat van links naar
rechts). De compiler vindt de waarde 20 en kent die toe aan
c, gaat verder naar links en ontdekt dat het resultaat van
de voorgaande berekening (20) ook aan b moet worden
toegekend, gaat verder naar links en kent 20 ook aan a toe.
Het laatste statement laat nog zien dat het ook om werkelijke
berekeningen mag gaan.
Het programma drukt niets af, dus compileren en testen heeft niet echt
veel zin. Wil je het programma toch testen, voeg dan printf
statements toe. Je weet inmiddels hoe dat moet.
Dan is nu het moment gekomen een regel te geven die moet worden
opgevolgd in C: Variabelen moeten altijd worden gedeclareerd VOOR
het eerst uitvoerbare statement van een programma blok. Om deze reden
zul je variabelen declaraties altijd bovenaan in een C programma
vinden. Als je een nieuwe variabele hebt gedeclareerd NA een statement,
zal de compiler een foutboodschap geven.
Toekennen aan andere data types
Programma TKANDER.C laat zien hoe nog andere datatypes gebruikt kunnen
worden. Opnieuw zijn hier een paar integer variabelen gedeclareerd, die
je nu bekend voor zullen komen. Er zijn ook twee nieuwe types aan
toegevoegd, char en float.
<![CDATA[
main ()
{
int a, b, c; /* -32768 tot 32767 zonder komma */
char x ,y, z; /* 0 tot 255 zonder komma */
float jan, piet, klaas; /* 10E-38 tot 10E+38 met momma */
a = b = c = -27; /* initialisatie */
x = y = z = 'A';
jan = piet = klaas = 9.7531;
a = y; /* a wordt 65 (karakter A) */
x = b; /* x wordt een vreemd karakter */
jan = b; /* jan wordt -27.00 */
a = piet; /* a wordt 9 */
}
]]>
Het type char is vrijwel gelijk aan de integer. Character
variabelen echter kunnen slechts waarden bevatten van 0 tot en met 255
en beslaan 1 byte in het geheugen. Het type char wordt
normaal gesproken gebruikt om er ASCII tekens in op te slaan of, om het
anders uit te drukken, tekst. De tekst die je nu leest bijvoorbeeld
werd geschreven op een computer met behulp van een tekstverwerker, die
de woorden teken voor teken in het geheugen opslaat. In tegenstelling
daarmee worden integers, op de meeste computers, opgeslagen in twee
aaneengesloten bytes in het geheugen.
Verschillende datatypes tegelijk
Laten we eens gaan kijken hoe C omgaat met de types char en
int. Veel funkties die C biedt zijn zo ontworpen dat ze
zowel met integer- als met character variabelen kunnen werken.
De funkties die als parameter een variabele van het type
char verwachten, zullen dit karakter intern beschouwen als
een integer en daar als zodanig mee werken. Het is daarom mogelijk
char en int type variabelen onderling uit te
wisselen. De compiler zal er niets van zeggen. Het is echter niet
verstandig dit te doen vanuit ontwerp standpunt. Het is verstandiger
zoveel mogelijk de toekenningen te doen met variabelen van hetzelfde
type.
Het tweede nieuwe datatype is de float, ook wel bekend als
floating point. Dit datatype heeft een groot waardebereik, een groot
aantal decimalen en beslaat een groot aantal bytes in het geheugen. De
float bevat een impliciet komma-getal.
Hoe wordt met de nieuwe datatypes gewerkt
De eerste drie regels van het programma TKANDER.C kent waarden toe aan
alle negen variabelen, zodat we wat kunnen manipuleren met de datatypes
onderling.
Omdat, zoals al eerder gezegd, een type char overeenkomt met
een type int, hoeven we geen speciale voorzieningen te
treffen om een character aan een integer toe te kennen. Omgekeerd ligt
het wat moeilijker. Je kunt onvoorspelbare resultaten krijgen als de
waarde van de integer buiten het waardebereik van het character ligt,
ofwel groter is dan 255. Binnen dat bereik zal alles goed gaan, met
andere woorden als de waarde van de integer 0 tot en met 255 is. In het
voorbeeld waarbij -27 wordt toegekend aan character x zijn
de resultaten slecht voorspelbaar en afhankelijk van de implementatie
van de gebruikte C compiler.
De derde regel laat zien hoe eenvoudig het is een integer naar een
floating point variabele te vertalen. Een toekenning programmeren is
voldoende, het systeem regelt de conversie. De weg terug is wat
moeilijker. Omdat er een getal achter de komma kan zijn (de z.g.
fractie) en een integer geen fractie kent, gaat bij deze conversie
informatie verloren. De fractie wordt eenvoudigweg afgekapt.
Het programma drukt niets af. We hebben het afdrukken van variabelen
anders dan van het type int nog niet behandeld. Compileren
en testen is op dit moment dus nog niet mogelijk. In de volgende
hoofdstukken komt dat aan de orde.
De data types van C
Bestudeer het programma DATATYPS.C. Dit programma bevat alle standaard
datatypes die in de programmeertaal C beschikbaar zijn. Er zijn nog
andere datatypes, de structuren, maar die zullen we later behandelen.
<![CDATA[
main ()
{
int a;
long int b;
short int c;
unsigned int d;
char e;
float f;
double g;
a = 1023; /* initialisatie */
b = 2222;
c = 123;
d = 1234;
e = 'X';
f = 3.14159;
g = 3.1415926535898;
printf ("a = %d \n", a); /* decimaal afgedrukt */
printf ("a = %o \n", a); /* octaal afgedrukt */
printf ("a = %x \n", a); /* hexadecimaal afgedrukt */
printf ("b = %ld \n", b); /* decimaal 'long' */
printf ("c = %hd \n", c); /* decimaal 'short' */
printf ("d = %u \n", d); /* 'unsigned' */
printf ("e = %c \n", e); /* character */
printf ("f = %f \n", f); /* floating point */
printf ("g = %g \n", g); /* double float */
printf ("\n");
printf ("a = %d \n", a); /* integer gewoon afgedrukt */
printf ("a = %7d \n", a); /* integer op veldbreedte 7 */
printf ("a = %-7d \n", a); /* links aangesloten, 7 breed */
printf ("\n");
printf ("f = %f \n", f); /* float gewoon afgedrukt */
printf ("f = %12f \n", f); /* float op veldbreedte 12 */
printf ("f = %12.3f \n", f); /* 12 breed met 3 decimalen */
printf ("f = %12.5f \n", f); /* 12 breed met 5 decimalen */
printf ("f = %-12.5f \n", f); /* links aangesloten */
}
]]>
Eerst wordt een eenvoudige int gedeclareerd gevolgd door
een long int en een short int. Je zult altijd in
het Reference Manual van de gebruikte compiler moeten kijken voor een
exacte definitie van deze typen, omdat ze implementatie afhankelijk
zijn.
Daarna komt de unsigned, die even groot is als de
int, maar geen teken heeft. De unsigned zal op de
meeste computers een bereik hebben van 0 tot en met 65535. Bij de
declaratie van de typen long, short en
unsigned mag het woord int worden weggelaten.
De char en de float hebben we inmiddels
behandeld, zodat alleen de double nog overblijft. De
double heeft een groter waarde bereik dan de
float en heeft meer cijfers beschikbaar voor nauwkeuriger
berekeningen. Er is ook meer geheugen nodig om een double op
te slaan. Een float variabele beslaat 4 bytes en een
double beslaat 8 bytes in het geheugen. Kijk altijd in het
Reference Manual van de compiler om precies te weten wat de precisie is.
Nadat in het programma variabelen van de diverse datatypes gedeclareerd
zijn, wordt aan elk ervan een waarde toegekend. Met behulp hiervan zal
in het volgende hoofdstuk gedemonstreerd worden hoe deze af te drukken.
Conversie karakters en printf
Het volgende overzicht is een lijst van conversie karakters en de
manier waarop ze gebruikt moeten worden bij de printf()
funktie:
| Karakter | Gebruik |
| d | decimale notatie |
| o | octale notatie |
| x | hexadecimale notatie |
| u | unsigned notatie |
| c | character notatie |
| s | string notatie |
| f | floating point notatie |
Elk van deze karakters wordt gebruikt in combinatie met het procent
teken (%), die de printf() funktie vertelt welke conversie er
plaats moet vinden. Tussen deze twee tekens mag nog extra besturing
worden toegevoegd:
| Karakter | Funktie |
| - | links aansluiten in het veld |
| (n) | een getal dat de minimum veld breedte aangeeft |
| . | scheidings teken (scheidt n van m) |
| (m) | aantal cijfers achter de komma |
| l | duidt een long variabele aan |
Deze tekens worden in het voorbeeld programma toegepast. De string
notatie vormt een uitzondering. Daar zullen we later in de cursus op
terugkomen. Vanaf nu ben je dus in staat om alle mogelijke gegevens af
te drukken.
Compileer en test het programma en probeer nog eens wat andere
mogelijkheden uit.
Logisch vergelijken
Bestudeer nu het programma VERGELYK.C, waarin een aantal voorbeelden
van vergelijkingen staan. Het programma begint met de declaratie en
initialisatie van een negen-tal variabelen die daarna in een aantal
vergelijkingen worden gebruikt. De manier waarop dat hier gebeurd is
wellicht nieuw voor je en volledig toegestaan in C.
<![CDATA[
main ()
{
int x = 11, y = 11, z = 11;
char a = 40, b = 40, c = 40;
float r = 12.987, s = 12.987, t = 12.987;
/* Eerste groep */
if (x == y) z = -13; /* z wordt -13 */
if (x > z) a = 'A'; /* a wordt 65 */
if (!(x > z)) a = 'B'; /* er verandert niets */
if (b <= c) r = 0.0; /* r wordt 0.0 */
if (r != s) t = c / 2; /* t wordt 20 */
/* Tweede groep */
if (x = (r != s)) z = 1000; /* x wordt WAAR, z wordt 1000 */
if (x = y) z = 222; /* x wordt y, z wordt 222 */
if (x != 0) z = 333; /* z wordt 333 */
if (x) z = 444; /* z wordt 444 */
/* Derde groep */
x = y = z = 77; /* initialisatie */
if ((x == y) && (x == 77)) z = 33; /* z wordt 33 */
if ((x > y) || (z > 12)) z = 22; /* z wordt 22 */
if (x && y && z) z = 11; /* z wordt 11 */
if ((x = 1) && (y = 2) && (z = 3)) r = 12.00;
/* x wordt 1, y wordt 2, z wordt 3, r wordt 12.00 */
if ((x == 2) && (y = 3) && (z = 4)) r = 14.56;
/* er verandert niets */
/* Vierde groep */
if (x == x); z = 27.345; /* z veranderd altijd ! */
if (x != x) z = 27.345; /* z veranderd niet */
if (x = 0) z = 27.345; /* x wordt 0, z veranderd niet */
}
]]>
De eerste groep van vergelijkingen
De eerste groep van vergelijkingen geven de eenvoudigste vorm van
vergelijken weer, omdat ze slechts twee variabelen vergelijken. Elke
variabele mag vervangen worden door een constante, echter twee
constanten met elkaar vergelijken lijkt weinig zinvol. De eerste
vergelijking controleert of x gelijk is aan y en
gebruikt daarvoor een dubbel is-gelijk (==) teken als operator. C
gebruikt het enkele is-gelijk teken (=) voor de toekenning. De tweede
vergelijking controleert of x groter is dan y.
De derde introduceert de not operator, zijnde het
uitroepteken, die gebruikt wordt om het resultaat van een logische
vergelijking te inverteren. De vierde controleert of b
kleiner of gelijk is aan c De laatste controleert of
r ongelijk is aan s.
In het voorgaande hoofdstuk hebben we geleerd dat als de expressie
volgend op if WAAR is, het statement van de if
wordt uitgevoerd. De resultaten van de voorbeelden staan er als
commentaar achter vermeld.
Om het voorbeeld compact te houden is hier alles zo veel mogelijk op
een regel gezet, hetgeen afwijkt van de voorgestelde standaard.
De tweede groep van vergelijkingen
De tweede groep komt al wat meer ter zake. De eerste bevat een wat
vreemd aandoende expressie tussen de haakjes. Om te begrijpen wat hier
staat zullen we eerst moeten weten wat een WAAR (true) en een ONWAAR
(false) is in de programmeertal C. De waarde nul is gedefinieerd als
ONWAAR (false) en elke niet-nul waarde als WAAR (true). Elke integer of
character variabele kan worden gebruikt voor het opslaan van het
resultaat van een vergelijking. Met andere woorden,
boolean variabelen mogen gedeclareerd worden met behulp van
variabelen van het type int of char.
Kijk nu eens naar het eerste voorbeeld. De expressie r != s
zal ge‰valueerd worden als WAAR, omdat r de waarde 0.0
gekregen heeft. Het resultaat zal dus niet-nul zijn en het meest
waarschijnlijk is dat de waarde 1. Hoewel de twee variabelen waarmee
wordt vergeleken van het type float zijn, zal het resultaat
van het type integer zijn. Het resultaat wordt namelijk niet aan een
specifieke variabele toegekend, waardoor het resultaat impliciet een
integer is. Tenslotte wordt het resulterende getal, hier 1, aan de
integer variabele x toegekend.
Als er twee is-gelijk tekens (==) hadden gestaan, zou een systeem
variabele de waarde 1 gekregen hebben en zou deze variabele vergeleken
zijn met x. Omdat er slechts een is-gelijk teken staat, is
er sprake van een toekenning. Omdat het resultaat van de vergelijking
nu dus ook niet-nul is, is het resultaat van de hele vergelijking WAAR
en krijgt z de waarde 1000. We hebben hiermee twee dingen
tegelijk gedaan in dit statement; x kreeg een nieuwe waarde
en z werd 1000.
Met dit voorbeeld hebben we een aantal dingen tegelijk behandeld. Kijk
een en ander nog eens na en ga dan pas verder. De belangrijke dingen
waren de definitie van WAAR en ONWAAR in C en het feit dat toekenning
in een uitvraging is toegestaan.
Het voorbeeld erna maakt het wellicht nog eens duidelijk. Variabele
x krijgt de waarde van variabele y. Omdat dit 11
is, is het resultaat niet-nul, dus WAAR, dus krijgt variabele
z de waarde 222.
In het derde voorbeeld wordt x vergeleken met nul. Omdat
x ongelijk is aan nul is het resultaat ONWAAR. Dit wordt
ge‹nverteerd, dus WAAR. Variabele z krijgt dus de waarde
333.
Ook hier geldt weer het concept van WAAR en ONWAAR. Voorbeeld drie
en vier laten een en ander nog eens opnieuw zien.
De derde groep van vergelijkingen
De derde groep behandelt de logische and en de logische
or. De drie variabelen krijgen eerst de waarde 77 toegekend.
De eerste vergelijking bevat de && operator, wat de
logische and is. Het statement luidt: als x
gelijk is aan y EN als x gelijk is aan
77 dan is het resultaat WAAR. Omdat dit WAAR is, wordt z 33.
De volgende vergelijking introduceert de || operator, die de
logische or is. Het statement luidt: als x
groter is dan y OF als z groter is dan
12, is het resultaat WAAR. Omdat z groter is dan 12 maakt
het niet meer uit of x groter is dan y of niet.
Het resultaat is WAAR, daarom wordt z 22.
De vierde groep van vergelijkingen
De vierde groep laat een valkuil zien, waar veel beginnende C
programmeurs invallen. Na de sluithaak van de expressie van de
if staat direct een punt-komma (;). Het gevolg is een
loos statement (NOP). Variabele z zal dus altijd een nieuwe
waarde krijgen. Wees hierop bedacht.
In het tweede voorbeeld wordt x met zichzelf vergeleken,
hetgeen altijd WAAR zal zijn. Het statement zal ONWAAR opleveren
en dus in het geheel niets doen, wat verloren moeite is.
Het laatste statement tenslotte zal altijd de waarde nul aan
x toekennen en dus ONWAAR opleveren. Het statement achter de
voorwaarde zal dus nooit worden uitgevoerd.
Evaluatie van expressies
Evaluatie van een samengestelde expressie vindt plaats van links naar
rechts en zodra het resultaat zeker is, stopt de evaluatie. In het
geval van een and zal de evaluatie stoppen zodra het
resultaat van een van de termen van de expressie ONWAAR is. De
evaluatie kan worden gestaakt, omdat de hele expressie nooit meer WAAR
kan worden. In het geval van een or zal de evaluatie stoppen
zodra het resultaat van een van de termen van de expressie WAAR is. De
evaluatie kan worden gestaakt, omdat de hele expressie nooit meer
ONWAAR kan worden.
Beslissingen (statements met een voorwaarde) zijn bijzonder belangrijk
en moeten goed doordacht worden om zo efficiënt mogelijke C programma's
te schrijven. Als nog niet alles wat er besproken is tot je is
doorgedrongen, raadt ik je aan een en ander nog eens door te lezen.
Voorrang regels
Het is altijd weer de vraag welke de voorrang regels zijn die de
compiler hanteert tussen de diverse operators. Welke operators gaan
voor de andere. Denk hierbij aan vermenigvuldigen en
delen die voor optellen en aftrekken
gaan. Ik wil voorstellen om dit niet aan het toeval over te laten, doch
expressies van zoveel mogelijk haakjes te voorzien. Haakjes hebben de
hoogste voorrang en maken in een klap duidelijk wat er precies moet
gebeuren. Kijk eens naar de voorbeelden uit de derde groep van het
programma VERGELYK.C.
Taal specifieke delen van C
De programmeertaal C biedt drie zeer specifieke constructies die, als
je ze de eerste keer ziet, wat vreemd aandoen. Zij laten de compiler
echter erg snelle code genereren en worden door ervaren programmeurs
uitgebreid gebruikt. Ze zullen daarom nu behandeld worden, want je zult
ze in vrijwel elk C programma tegenkomen. Bestudeer nu programma
PLUSMIN.C.
<![CDATA[
main ()
{
int x = 0, y = 2, z = 1025;
float a = 0.0, b = 3.14159, c = -37.234;
/* Ophogen */
x = x + 1; /* x wordt 1 hoger */
x++; /* x wordt 1 hoger */
++x; /* x wordt 1 hoger */
z = y++; /* z wordt 2, y wordt 3 */
z = ++y; /* z wordt 4, y wordt 4 */
/* Aflagen */
y = y - 1; /* x wordt 1 lager */
y--; /* x wordt 1 lager */
--y; /* x wordt 1 lager */
y = 3; /* y wordt 3 gemaakt */
z = y--; /* z wordt 3, y wordt 2 */
z = --y; /* z wordt 1, y wordt 1 */
/* Rekenkundige bewerkingen */
a = a + 12; /* a wordt 12 hoger */
a += 12; /* a wordt weer 12 hoger */
a *= 3.2; /* a vermenigvuldigd met 3.2 */
a -= b; /* b wordt afgetrokken van a */
a /= 10.0; /* a wordt gedeeld door 10 */
/* Conditional expression */
a = (b >= 3.0 ? 2.0 : 10.5); /* Deze constructie is */
/* identiek aan: */
if (b >= 3.0) a = 2.0;
else a = 10.5;
c = (a > b ? a : b); /* c wordt maximum van a en b */
c = (a > b ? b : a); /* c wordt minimum van a en b */
}
]]>
In dit programma worden eerst wat variabelen gedeclareerd en
ge‹nitialiseerd. Het eerste statement telt eenvoudigweg 1 op bij de
waarde van x, hetgeen geen verrassing meer voor je moet
zijn. De volgende twee statements tellen ook 1 op bij de waarde van
x, echter nu is dat niet zo duidelijk meer zichtbaar als bij
het vorige statement. In de programmeertaal C is deze bewerking
gedefinieerd. Twee plus tekens achter elkaar, voor of achter een
variabele geplaatst hoogt die variabele met 1 op.
Er is echter nog meer aan de hand. Als de plus tekens ervoor staan
wordt de variabele eerst opgehoogd en daarna gebruikt. Als de plus
tekens erachter staan wordt de variabele eerst gebruikt en daarna
opgehoogd. Laten we kijken naar de voorbeelden. De waarde van
y wordt toegekend aan de variabele z en daarna
wordt y opgehoogd, want de plus tekens staan achter de
variabele y. In het laatste statement van de groep wordt de
waarde van y eerst opgehoogd en vervolgens toegekend aan de
variabele z.
De volgende groep statements laat zien hoe het aflagen in zijn werk
gaat. De definitie voor aflagen werkt net zo als die voor ophogen. Als
de min tekens ervoor staan wordt de variabele eerst afgelaagd, daarna
gebruikt en als de min tekens erachter staan wordt de variabele eerst
gebruikt, daarna afgelaagd.
Een andere vreemde maar bruikbare operator is die voor rekenkundige
bewerkingen. Deze operator wordt gebruikt om een variabele te
veranderen met een bepaalde waarde. Het eerste statement uit de groep
voorbeelden telt (op klassieke wijze) 12 op bij de waarde van de
variabele a. Het tweede voorbeeld doet exact hetzelfde,
echter nu op C specifieke wijze. Alle vier basis bewerkingen (optellen,
aftrekken, vermenigvuldigen en delen) kunnen op deze wijze worden
geprogrammeerd. Plaats het symbool van de bewerking direct
voor het is-gelijk teken en laat de tweede referentie naar
de naam van de variabele achterwege.
Nog een opmerking. De expressie rechts van het is-gelijk teken mag elke
geldige expressie zijn. De voorbeelden zijn bewust eenvoudig gehouden,
zodat je er makkelijk vertrouwd mee raakt.
Tenslotte wordt de derde constructie besproken, de Conditional
Expression. Deze constructie is al even vreemd als de vorige
twee en specifiek voor C. Probeer ook deze te doorgronden, want ervaren
C programmeurs gebruiken hem veel. Je zult hem dus vaak tegenkomen.
De Conditional Expression is opgebouwd uit drie delen die van elkaar
gescheiden zijn door een vraagteken (?) en een dubbele punt (:). De
expressie voor het vraagteken wordt ge‰valueerd en resulteert in WAAR
of ONWAAR. Als de expressie WAAR is, wordt het statement na het
vraagteken gebruikt als rechterdeel van een toekenning; als de
expressie ONWAAR is wordt het statement na de dubbele punt gebruikt als
rechterdeel van een toekenning. Het uiteindelijke resultaat komt
overeen met dat van een if statement met een else
tak. Het tweede voorbeeld uit de groep laat dit nog eens zien. De
Conditional Expression heeft het voordeel dat je compactere programma's
kunt schrijven die met veel compilers ook snellere machinecode
opleveren.
De laatste twee voorbeelden laten een compacte manier van coderen
zien voor respectievelijk de max() en de min()
funkties.
Veel programmeurs zeggen dat ze de bovengenoemde constructies van C
niet mooi vinden en ze dus ook niet zullen gebruiken. Zolang ze
programma's van en voor zich zelf schrijven en in onderhoud hebben,
is dat geen enkel bezwaar. Op het moment echter dat programma code van
anderen gebruikt of onderhouden moet gaan worden, is het handig als
je van deze programmeer-technieken op de hoogte bent. Ook in de
voorbeelden bij deze cursus zul je ze tegen komen.
Dit was een lang hoofdstuk. Het bevatte een aantal belangrijke concepten
om je met C op weg te helpen. In het volgende hoofdstuk zal het gaan over
de bouwstenen van C, de funkties. Met die kennis zal je reeds in staat
zijn zinvolle programma's te bouwen.
|
