{"id":210,"date":"2022-01-20T15:55:25","date_gmt":"2022-01-20T14:55:25","guid":{"rendered":"https:\/\/wiskunst.hjgsoft.nl\/?page_id=210"},"modified":"2022-01-24T09:36:55","modified_gmt":"2022-01-24T08:36:55","slug":"gestructureerde-types","status":"publish","type":"page","link":"https:\/\/wiskunst.nl\/index.php\/programmeren1\/programmeren\/gestructureerde-types\/","title":{"rendered":"Gestructureerde types"},"content":{"rendered":"

We hebben al een aantal keer (gedwongen) gebruik gemaakt van een type-declaratie voor strings.
\nPascal kent het principe van zelfgemaakte types.
\nIn hoofdstuk 8 (of 9) hebben we hier een paar voorbeelden van gezien.
\nIn dit hoofdstuk gaan we ons bezig houden met gestructureerde types.
\nDeze versie van Pascal kent twee gestructureerde types, nl. de\u00a0array<\/b>\u00a0en de\u00a0record<\/b>.
\nIn latere versies (waaronder Delphi) is daar een derde bijgekomen, nl. de\u00a0class<\/b>.<\/p>\n

Array’s.<\/h2>\n

Een string is (wederom in deze versie van Pascal) een array van karakters.
\nHet voordeel van een array is dat je een (groot) aantal bij elkaar horende waardes effici\u00ebnt kan opslaan terwijl iedere waarde afzonderlijk benaderbaar blijft.
\nLaten we maar vlug naar het eerste voorbeeld gaan kijken:<\/p>\n

program\u00a0p12_1;<\/span><\/p>\n

type<\/span>
\n\u00a0 TDobbelsteen = array[1..6] of integer;<\/span><\/p>\n

var<\/span>
\n\u00a0 Dobbelsteen: TDobbelsteen;<\/span><\/p>\n

procedure\u00a0InitDobbelsteen(var\u00a0ds:\u00a0TDobbelsteen);<\/span>
\n\u00a0 var x: byte;<\/span>
\nbegin<\/span>
\n\u00a0 for x := 1 to 6 do<\/span>
\n\u00a0 \u00a0 ds[x] := 0;<\/span>
\nend;<\/span><\/p>\n

procedure\u00a0Gooi(aantal:\u00a0integer;var\u00a0ds:\u00a0TDobbelsteen);<\/span>
\n\u00a0 var<\/span>
\n\u00a0 \u00a0 x: integer;<\/span>
\n\u00a0 \u00a0 w: byte;<\/span>
\nbegin<\/span>
\n\u00a0 for x := 1 to aantal do<\/span>
\n\u00a0 \u00a0 begin<\/span>
\n\u00a0 \u00a0 \u00a0 w := trunc(random * 6);<\/span>
\n\u00a0 \u00a0 \u00a0 ds[w] := ds[w] + 1;<\/span>
\n\u00a0 \u00a0 end;<\/span>
\nend;<\/span><\/p>\n

procedure\u00a0Toon(ds:\u00a0TDobbelsteen);<\/span>
\n\u00a0 var x: byte;<\/span>
\nbegin<\/span>
\n\u00a0 for x := 1 to 6 do<\/span>
\n\u00a0 \u00a0 write(x:8);<\/span>
\n\u00a0 writeln;<\/span>
\n\u00a0 for x := 1 to 6 do<\/span>
\n\u00a0 \u00a0 write(ds[x]:8);<\/span>
\n\u00a0 writeln;<\/span>
\nend;<\/span><\/p>\n

begin<\/span>
\n\u00a0 randomize;<\/span>
\n\u00a0 InitDobbelsteen(Dobbelsteen);<\/span>
\n\u00a0 Gooi(1000,Dobbelsteen);<\/span>
\n\u00a0 Toon(Dobbelsteen);<\/span>
\nend.<\/span><\/p>\n

Het programma simuleert het 1000 keer gooien met een dobbelsteen en toont vervolgens hoe vaak iedere kant (1 t\/m 6) is gevallen.
\nIn dit voorbeeld wordt eerst een type\u00a0TDobbelsteen<\/b>\u00a0gedeclareerd als een array met 6 elementen van het type integer.
\nVervolgens wordt een variabele\u00a0Dobbelsteen<\/b>\u00a0van het zojuist gemaakte type TDobbelsteen gedeclareerd.
\nDe variabele Dobbelsteen is eigenlijk een bundeling van 6 integer-variabelen.
\nWanneer je een specifieke variabele uit Dobbelsteen wilt benaderen dan geef je z’n rangnummer tussen blokhaken aan.
\nAls ik hier bv. de waarde van 4-e variabele wil weten dan benader ik die met\u00a0Dobbelsteen[4]<\/b>.
\nMet de functie\u00a0random<\/b>\u00a0wordt een pseudo-willekeurig re\u00ebel getal tussen de 0 en 1 gekozen, waarbij 0 wel en 1 niet meedoet.
\nMet de functie\u00a0trunc([getal])<\/b>\u00a0wordt alles achter de komma van\u00a0getal<\/i>\u00a0afgekapt (dus niet afgerond!).
\nMet het commando\u00a0randomize<\/b>\u00a0wordt de ‘randomizer’ geschud, anders zou je bij iedere run van het programma dezelfde serie getallen krijgen.
\nDe rest van het programma moet duidelijk zijn.
\nOverigens is het in Turbo Pascal toegstaan om het array-type in de variabele-decalratie op te nemen.
\nHierboven zou je dus ook deze declaratie kunnen gebruiken:\u00a0var Dobbelsteen: array[1..6] of integer<\/b>.
\nDit is weer niet toegestaan bij parameter-declaraties!<\/p>\n

Het voorbeeld hierboven maakte gebruik van een 1-dimensionale-array. Dit zeggende begrijpt de aandachte lezer dat er dus ook meer-dimensionale-array’s bestaan. En dat is juist.
\nIn het volgende voorbeeld gaan we kijken naar een 2-dimensionale array:<\/p>\n

program\u00a0p12_2;<\/span><\/p>\n

const<\/span>
\n\u00a0 dim = 5;<\/span><\/p>\n

type<\/span>
\n\u00a0 TMatrix = array[1..dim,1..dim] of integer;<\/span><\/p>\n

var<\/span>
\n\u00a0 Matrix: TMatrix;<\/span><\/p>\n

procedure\u00a0ToonMatrix(m:\u00a0TMatrix);<\/span>
\n\u00a0 var x,y: byte;<\/span>
\nbegin<\/span>
\n\u00a0 writeln;<\/span>
\n\u00a0 for x := 1 to dim do<\/span>
\n\u00a0 \u00a0 begin<\/span>
\n\u00a0 \u00a0 \u00a0 for y := 1 to dim do<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 write(m[x,y]:4);<\/span>
\n\u00a0 \u00a0 \u00a0 writeln;<\/span>
\n\u00a0 \u00a0 end;<\/span>
\nend;<\/span><\/p>\n

procedure\u00a0VulMatrix(var\u00a0m:\u00a0TMatrix);<\/span>
\n\u00a0 var x,y: Byte;<\/span>
\nbegin<\/span>
\n\u00a0 for x := 1 to dim do<\/span>
\n\u00a0 \u00a0 for y := 1 to dim do<\/span>
\n\u00a0 \u00a0 \u00a0 m[x,y] := trunc(random*100);<\/span>
\nend;<\/span><\/p>\n

begin<\/span>
\n\u00a0 randomize;<\/span>
\n\u00a0 VulMatrix(Matrix);<\/span>
\n\u00a0 ToonMatrix(Matrix);<\/span>
\nend.<\/span><\/p>\n

Het enige wat dit programmaatje doet is een matrix van 5×5 vullen met willekeurige getallen en vervolgens deze matrix op het scherm tonen.
\nIn dit programma heb ik gebruik gemaakt van een\u00a0constante<\/i>-declaratie.
\nDe syntax luidt:<\/p>\n

const [naam] = [waarde];
\n<\/b>
\nVervolgens kun je overal waar je iets van\u00a0[waarde]<\/i>\u00a0wilt gebruiken revereren aan\u00a0[naam]<\/i>.
\nMocht later blijken dat\u00a0[naam]<\/i>\u00a0toch een andere waarde moet hebben, dan hoef je dat alleen maar in de\u00a0constante<\/i>-declaratie-regel aan te passen.
\nIn het programma hierboven werken we dus met een variabele Matrix van 5×5. Wat hier de x-dimensie en de y-dimensie is laat Pascal graag aan onze fantasie over.
\nIn principe kent Pascal geen beperkingen aan het aantal dimensies van array’s.
\nDe rest moet weer voor zich spreken.<\/p>\n

Record’s.<\/h2>\n

Een record is een type met variabelen (in deze context\u00a0velden<\/i>\u00a0genoemd) die logischerwijs bij elkaar horen.
\nDe syntax luidt:<\/p>\n

type
\n[naam] = record
\n[veld1]: [type_a];
\n[veld2],[veld3]: [type_b];
\n[veld4]: [type_c];
\nend;
\n<\/b>
\nDus een record moet een naam hebben, en wordt omsloten met\u00a0record<\/b>\u00a0en\u00a0end;<\/b>.
\nHier binnen declareer je de velden (=variabelen) die je nodig hebt. De type’s van die velden mogen op hun beurt ook weer gestructureerd zijn.
\nIn het volgende voorbeeld gaan we stoeien met een NAW-record waar we NAW-gegevens van een persoon in gaan opslaan.<\/p>\n

program\u00a0P12_3;<\/span><\/p>\n

type<\/span>
\n\u00a0 s80 = string[80];<\/span>
\n\u00a0 s40 = string[40];<\/span>
\n\u00a0 s20 = string[20];<\/span>
\n\u00a0 s15 = string[15];<\/span>
\n\u00a0 s7 = string[7];<\/span>
\n\u00a0 TNAW =<\/span>
\n\u00a0 \u00a0 record<\/span>
\n\u00a0 \u00a0 \u00a0 achternaam: s40;<\/span>
\n\u00a0 \u00a0 \u00a0 voorletters: s15;<\/span>
\n\u00a0 \u00a0 \u00a0 voornaam: s20;<\/span>
\n\u00a0 \u00a0 \u00a0 adres: s40;<\/span>
\n\u00a0 \u00a0 \u00a0 postcode: s7;<\/span>
\n\u00a0 \u00a0 \u00a0 plaats: s20;<\/span>
\n\u00a0 \u00a0 \u00a0 leeftijd: byte;<\/span>
\n\u00a0 \u00a0 \u00a0 geslacht: char;<\/span>
\n\u00a0 \u00a0 \u00a0 naamcombi: array[1..2] of s80<\/span>
\n\u00a0 \u00a0 end;<\/span><\/p>\n

var<\/span>
\n\u00a0 NAW: TNAW;<\/span><\/p>\n

procedure\u00a0LeesNAWIn(var\u00a0naw:\u00a0TNAW);<\/span>
\n\u00a0 var w: char;<\/span>
\nbegin<\/span>
\n\u00a0 write(‘achternaam : ‘);<\/span>
\n\u00a0 readln(naw.achternaam);<\/span>
\n\u00a0 write(‘voorletters: ‘);<\/span>
\n\u00a0 readln(naw.voorletters);<\/span>
\n\u00a0 write(‘voornaam : ‘);<\/span>
\n\u00a0 readln(naw.voornaam);<\/span>
\n\u00a0 write(‘adres: ‘);<\/span>
\n\u00a0 readln(naw.adres);<\/span>
\n\u00a0 write(‘postcode: ‘);<\/span>
\n\u00a0 readln(naw.postcode);<\/span>
\n\u00a0 write(‘plaats: ‘);<\/span>
\n\u00a0 readln(naw.plaats);<\/span>
\n\u00a0 write(‘leeftijd: ‘);<\/span>
\n\u00a0 readln(naw.leeftijd);<\/span>
\n\u00a0 write(‘geslacht (M\/V): ‘);<\/span>
\n\u00a0 repeat<\/span>
\n\u00a0 \u00a0 read(kbd,w);<\/span>
\n\u00a0 until w in [‘m’,’M’,’v’,’V’];<\/span>
\n\u00a0 writeln(w);<\/span>
\n\u00a0 naw.geslacht := w;<\/span>
\n\u00a0 naw.naamcombi[1] := naw.voorletters + naw.achternaam;<\/span>
\n\u00a0 naw.naamcombi[2] := naw.voornaam + naw.achternaam;<\/span>
\nend;<\/span><\/p>\n

procedure\u00a0ToonNAW(naw:\u00a0TNAW);<\/span>
\nbegin<\/span>
\n\u00a0 with naw do<\/span>
\n\u00a0 \u00a0 begin<\/span>
\n\u00a0 \u00a0 \u00a0 writeln(‘achternaam: ‘,achternaam);<\/span>
\n\u00a0 \u00a0 \u00a0 writeln(‘voorletters:\u00a0‘,voorletters);<\/span>
\n\u00a0 \u00a0 \u00a0 writeln(‘voornaam:\u00a0‘,voornaam);<\/span>
\n\u00a0 \u00a0 \u00a0 writeln(‘adres:\u00a0‘,adres);<\/span>
\n\u00a0 \u00a0 \u00a0 writeln(‘postcode:\u00a0‘,postcode);<\/span>
\n\u00a0 \u00a0 \u00a0 writeln(‘plaats:\u00a0‘,plaats);<\/span>
\n\u00a0 \u00a0 \u00a0 writeln(‘leeftijd:\u00a0‘,leeftijd);<\/span>
\n\u00a0 \u00a0 \u00a0 write(‘geslacht:\u00a0‘);<\/span>
\n\u00a0 \u00a0 \u00a0 if\u00a0(geslacht=’m’)\u00a0or\u00a0(geslacht=’M’) then<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 writeln(‘Man’)<\/span>
\n\u00a0 \u00a0 \u00a0 else<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 writeln(‘Vrouw’);<\/span>
\n\u00a0 \u00a0 \u00a0 writeln(‘combi\u00a01:\u00a0‘,naamcombi[1]);<\/span>
\n\u00a0 \u00a0 \u00a0 writeln(‘combi\u00a02:\u00a0‘,naamcombi[2]);<\/span>
\n\u00a0 \u00a0 end;<\/span>
\nend;<\/span><\/p>\n

begin<\/span>
\n\u00a0 LeesNAWIn(NAW);<\/span>
\n\u00a0 writeln;<\/span>
\n\u00a0 writeln;<\/span>
\n\u00a0 ToonNAW(NAW);<\/span>
\nend.<\/span><\/p>\n

Bij de type-declaratie is record-type\u00a0TNAW<\/b>\u00a0gemaakt, waarin bepaalde waardes behorend bij een persoon logischerwijs bij elkaar zijn gezet.
\nLet even op het type van\u00a0naamcombi<\/i>, dit is een array.
\nVervolgens maken we een variabele\u00a0NAW<\/b>, waarin de gegevens daadwerkelijk kunnen worden opgeslagen.
\nOm bij een specifiek veld van NAW te komen, gebruiken we de punt-selector. Dus met\u00a0NAW.achternaam<\/b>\u00a0bereik je het veld\u00a0achternaam<\/i>.
\nBij de procedure\u00a0LeesNAWIn<\/b>\u00a0wordt hiervan bij de\u00a0read<\/i>’s gebruik gemaakt.
\nBij de procedure\u00a0ToonNAW<\/b>\u00a0maken we gebruik van de\u00a0with<\/b>-constructie. Hiermee onderdrukken we het gebruik van de punt-selector.
\nDe syntax luidt:<\/p>\n

with [variabele] do [opdracht];
\n<\/b>
\nHierbij is\u00a0[variabele]<\/i>\u00a0de naam van de variabele en\u00a0[opdracht]<\/i>\u00a0de opdracht waarmee je iets met de\u00a0[variabele]<\/i>\u00a0kunt doen. Ook hier mag\u00a0[opdracht]<\/i>\u00a0een samengestelde opdracht zijn.<\/p>\n

Het zou natuurlijk prettiger zijn als we de gegevens van meer dan \u00e9\u00e9n persoon zouden kunnen verwerken.
\nEn dat is dan ook de volgende uitbreiding van het programma.<\/p>\n

program\u00a0P12_4;<\/span><\/p>\n

const<\/span>
\n\u00a0 Max = 2;<\/span><\/p>\n

type<\/span>
\n\u00a0 s80 = string[80];<\/span>
\n\u00a0 s40 = string[40];<\/span>
\n\u00a0 s20 = string[20];<\/span>
\n\u00a0 s15 = string[15];<\/span>
\n\u00a0 s7 = string[7];<\/span>
\n\u00a0 TNAW =<\/span>
\n\u00a0 \u00a0 record<\/span>
\n\u00a0 \u00a0 \u00a0 achternaam:\u00a0s40;<\/span>
\n\u00a0 \u00a0 \u00a0 voorletters:\u00a0s15;<\/span>
\n\u00a0 \u00a0 \u00a0 voornaam:\u00a0s20;<\/span>
\n\u00a0 \u00a0 \u00a0 adres:\u00a0s40;<\/span>
\n\u00a0 \u00a0 \u00a0 postcode:\u00a0s7;<\/span>
\n\u00a0 \u00a0 \u00a0 plaats:\u00a0s20;<\/span>
\n\u00a0 \u00a0 \u00a0 leeftijd:\u00a0byte;<\/span>
\n\u00a0 \u00a0 \u00a0 geslacht:\u00a0char;<\/span>
\n\u00a0 \u00a0 \u00a0 naamcombi:\u00a0array[1..2]\u00a0of\u00a0s80;<\/span>
\n\u00a0 \u00a0 end;<\/span>
\nTNAWs\u00a0=\u00a0array[1..Max]\u00a0of\u00a0TNAW;<\/span><\/p>\n

var<\/span>
\n\u00a0 NAW: TNAWs;<\/span><\/p>\n

procedure\u00a0DrukToets;<\/span>
\n\u00a0 var c: char;<\/span>
\nbegin<\/span>
\n\u00a0 write(‘Druk op een toets…’);<\/span>
\n\u00a0 read(kbd,c);<\/span>
\n\u00a0 writeln;<\/span>
\nend;<\/span><\/p>\n

procedure\u00a0LeesNAWIn(var\u00a0naw:\u00a0TNAW);<\/span>
\n\u00a0 {dezelfde implementatie als in P12_3}<\/span><\/p>\n

procedure\u00a0ToonNAW(naw:\u00a0TNAW);<\/span>
\n\u00a0 {dezelfde implementatie als in P12_3}<\/span><\/p>\n

procedure\u00a0LeesNAWsIn;<\/span>
\n\u00a0 var x: byte;<\/span>
\nbegin<\/span>
\n\u00a0 for x := 1 to Max do<\/span>
\n\u00a0 \u00a0 begin<\/span>
\n\u00a0 \u00a0 \u00a0 writeln(‘Voer\u00a0de\u00a0‘,x,’-e\u00a0persoon in:’);<\/span>
\n\u00a0 \u00a0 \u00a0 writeln;<\/span>
\n\u00a0 \u00a0 \u00a0 LeesNAWIn(NAW[x]);<\/span>
\n\u00a0 \u00a0 \u00a0 writeln;<\/span>
\n\u00a0 \u00a0 end;<\/span>
\nend;<\/span><\/p>\n

procedure\u00a0ToonNAWs;<\/span>
\n\u00a0 var x: byte;<\/span>
\nbegin<\/span>
\n\u00a0 for x := 1 to Max do<\/span>
\n\u00a0 \u00a0 begin<\/span>
\n\u00a0 \u00a0 \u00a0 writeln(‘Gegevens\u00a0van\u00a0‘,x,’-e persoon:’);<\/span>
\n\u00a0 \u00a0 \u00a0 writeln;<\/span>
\n\u00a0 \u00a0 \u00a0 ToonNAW(NAW[x]);<\/span>
\n\u00a0 \u00a0 \u00a0 writeln;<\/span>
\n\u00a0 \u00a0 \u00a0 DrukToets;<\/span>
\n\u00a0 \u00a0 \u00a0 writeln;<\/span>
\n\u00a0 \u00a0 end;<\/span>
\nend;<\/span><\/p>\n

begin<\/span>
\n\u00a0 LeesNAWsIn;<\/span>
\n\u00a0 writeln;<\/span>
\n\u00a0 writeln;<\/span>
\n\u00a0 ToonNAWs;<\/span>
\nend.<\/span><\/p>\n

Bij de type-declaraties is\u00a0TNAWs<\/b>\u00a0toegevoegd als array van\u00a0TNAW<\/b>. Het aantal NAW’s hangt af van de\u00a0const<\/b>ante\u00a0Max<\/b>.
\nDe variabele\u00a0NAW<\/b>\u00a0is nu van het type\u00a0TNAWs<\/b>.
\nDe procedure\u00a0LeesNAWsIn<\/b>\u00a0leest nu\u00a0Max<\/i>\u00a0NAW’s in.
\nDe procedure\u00a0ToonNAWs<\/b>\u00a0laat de\u00a0Max<\/i>\u00a0NAW’s per NAW zien, daartoe gebruik makend van de procedure\u00a0DrukToets<\/b>.<\/p>\n

Tot slot willen we de ingevoerde gegevens natuurlijk op schijf kunnen bewaren.
\nZoals in hoofdstuk 10 reeds vermeld kunnen we dat doen d.m.v. een binair bestand dat gekoppeld is aan een type.<\/p>\n

program\u00a0P12_5;<\/span><\/p>\n

const<\/span>
\n\u00a0 Max = 2;<\/span><\/p>\n

type<\/span>
\n\u00a0 s80 = string[80];<\/span>
\n\u00a0 s40 = string[40];<\/span>
\n\u00a0 s20 = string[20];<\/span>
\n\u00a0 s15 = string[15];<\/span>
\n\u00a0 s7 = string[7];<\/span>
\n\u00a0 TNAW =<\/span>
\n\u00a0 \u00a0 record<\/span>
\n\u00a0 \u00a0 \u00a0 achternaam:\u00a0s40;<\/span>
\n\u00a0 \u00a0 \u00a0 voorletters:\u00a0s15;<\/span>
\n\u00a0 \u00a0 \u00a0 voornaam:\u00a0s20;<\/span>
\n\u00a0 \u00a0 \u00a0 adres:\u00a0s40;<\/span>
\n\u00a0 \u00a0 \u00a0 postcode:\u00a0s7;<\/span>
\n\u00a0 \u00a0 \u00a0 plaats:\u00a0s20;<\/span>
\n\u00a0 \u00a0 \u00a0 leeftijd:\u00a0byte;<\/span>
\n\u00a0 \u00a0 \u00a0 geslacht:\u00a0char;<\/span>
\n\u00a0 \u00a0 \u00a0 naamcombi:\u00a0array[1..2]\u00a0of\u00a0s80;<\/span>
\n\u00a0 \u00a0 end;<\/span>
\nTNAWs\u00a0=\u00a0array[1..Max]\u00a0of\u00a0TNAW;<\/span><\/p>\n

var<\/span>
\n\u00a0 NAW: TNAWs;<\/span>
\n\u00a0 bNAW: file of TNAW;<\/span><\/p>\n

function\u00a0Bestaat(bn:\u00a0s80):\u00a0Boolean;<\/span>
\n\u00a0 var b: file;<\/span>
\nbegin<\/span>
\n\u00a0 assign(b,bn);<\/span>
\n\u00a0 {$I-}<\/span>
\n\u00a0 \u00a0 reset(b);<\/span>
\n\u00a0 {$I+}<\/span>
\n\u00a0 if IOResult = 0 then<\/span>
\n\u00a0 \u00a0 begin<\/span>
\n\u00a0 \u00a0 \u00a0 close(b);<\/span>
\n\u00a0 \u00a0 \u00a0 Bestaat := true;<\/span>
\n\u00a0 \u00a0 end<\/span>
\n\u00a0 else<\/span>
\n\u00a0 \u00a0 Bestaat := false;<\/span>
\nend;<\/span><\/p>\n

procedure\u00a0DrukToets;<\/span>
\n\u00a0 {dezelfde implementatie als in P12_4}<\/span><\/p>\n

procedure\u00a0LeesNAWIn(var\u00a0naw:\u00a0TNAW);<\/span>
\n\u00a0 {dezelfde implementatie als in P12_3}<\/span><\/p>\n

procedure\u00a0ToonNAW(naw:\u00a0TNAW);<\/span>
\n\u00a0 {dezelfde implementatie als in P12_3}<\/span><\/p>\n

procedure\u00a0LeesNAWsIn;<\/span>
\n\u00a0 {dezelfde implementatie als in P12_4}<\/span><\/p>\n

procedure\u00a0ToonNAWs;<\/span>
\n\u00a0 {dezelfde implementatie als in P12_4}<\/span><\/p>\n

procedure\u00a0NAWsNaarSchijf;<\/span>
\n\u00a0 var x: byte;<\/span>
\nbegin<\/span>
\n\u00a0 assign(bNAW,’NAWS.GSP’);<\/span>
\n\u00a0 rewrite(bNAW);<\/span>
\n\u00a0 for x := 1 to Max do<\/span>
\n\u00a0 \u00a0 write(bNAW,NAW[x]);<\/span>
\n\u00a0 close(bNAW);<\/span>
\nend;<\/span><\/p>\n

procedure\u00a0NAWsVanSchijf;<\/span>
\n\u00a0 var x: byte;<\/span>
\nbegin<\/span>
\n\u00a0 assign(bNAW,’NAWS.GSP’);<\/span>
\n\u00a0 reset(bNAW);<\/span>
\n\u00a0 for x := 1 to Max do<\/span>
\n\u00a0 \u00a0 read(bNAW,NAW[x]);<\/span>
\n\u00a0 close(bNAW);<\/span>
\nend;<\/span><\/p>\n

begin<\/span>
\n\u00a0 if Bestaat(‘NAWS.GSP’) then<\/span>
\n\u00a0 \u00a0 begin<\/span>
\n\u00a0 \u00a0 \u00a0 NAWsVanSchijf;<\/span>
\n\u00a0 \u00a0 \u00a0 ToonNAWs;<\/span>
\n\u00a0 \u00a0 end<\/span>
\n\u00a0 else<\/span>
\n\u00a0 \u00a0 begin<\/span>
\n\u00a0 \u00a0 \u00a0 LeesNAWsIn;<\/span>
\n\u00a0 \u00a0 \u00a0 writeln;<\/span>
\n\u00a0 \u00a0 \u00a0 writeln;<\/span>
\n\u00a0 \u00a0 \u00a0 ToonNAWs;<\/span>
\n\u00a0 \u00a0 \u00a0 NAWsNaarSchijf;<\/span>
\n\u00a0 \u00a0 end;<\/span>
\nend.<\/span><\/p>\n

Bij de variabele-declaratie is een variabele\u00a0bNAW: file of TNAW<\/b>\u00a0gedeclareerd. Met deze variabele kunnen we een bestand maken of lezen die als inhoud NAW-reocrds heeft. Deze records worden binair opgelagen.
\nDe functie\u00a0Bestaat<\/b>\u00a0is al in hoofdstuk 10 besproken.
\nDe procedure\u00a0NAWsNaarSchijf<\/b>\u00a0zet de NAW-records op schijf. Hierbij wordt het\u00a0write<\/b>-statement gebruikt en niet\u00a0writeln<\/b>.
\nDe procedure\u00a0NAWsVanSchijf<\/b>\u00a0leest de NAW-records van schijf. Hierbij wordt het\u00a0read<\/b>-statement gebruikt en niet\u00a0readln<\/b>.<\/p>\n

Tot zover dit uitgebreide hoofdstuk.
\nTot zover ook de basis van het programmeren.
\nDe eventuele verdere hoofdstukken behandelen andere gevorderde programmeer-zaken.<\/p>\n

Oefeningen.<\/h2>\n

<\/a>12.1<\/b>
\nSchrijf een programma dat twee matrices (maximale dimensie 10) vermenigvuldigd.
\nDe gebruiker moet eerst de dimensies van de 1e matrix ingeven. Hierna moeten de twee matrices worden ingelezen.
\nTen slotte moet de resultaat-matrix worden getoond.
\nDe matrix vermenigvuldiging gaat als volgt:
\nHet element (x,y) van de resultaat matrix is de som van de producten van de oplopende elementen van de x-e rij van de eerste matrix met de oplopende elementen van de y-e kolom van de tweede matrix.
\nDat betekend dat wanneer de eerste matrix de dimensie axb heeft de tweede als dimensie bxa moet hebben.
\nVerder zal de resultaat-matrix een vierkante dimensie hebben van axa als a groter is dan b, anders bxb.
\nVoorbeeldje:<\/p>\n

|1|\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0|3 4|
\n| | x (3 4) = |\u00a0\u00a0\u00a0|
\n|2|\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0|6 8|
\n<\/b><\/span><\/p>\n

[Antwoord<\/a>]\n

<\/a>12.2<\/b>
\nSchrijf een programma dat een datum als string inleest en deze middels een procedure omzet naar een variabele van het type\u00a0TDatum<\/b>.
\nUiteraard moet de procedure testen of de string wel een datum is! Zo niet dan worden alle velden (zie volgende regel) op 0 gezet.
\nHet type\u00a0TDatum<\/b>\u00a0is een, zelf te maken, record-type met de volgende integer-velden:\u00a0jaar<\/i>,\u00a0maand<\/i>\u00a0en\u00a0dag<\/i>.
\nVervolgens moeten er drie functies bestaan die uit een TDatum-variabele resp. het\u00a0Jaar<\/b>,\u00a0Maand<\/b>\u00a0en\u00a0Dag<\/b>\u00a0als integer moeten halen.
\nTest alles door de invoer middels de functies als uitvoer te geven. [Antwoord<\/a>]\n

<\/a>12.3<\/b>
\nDe meest complexe tot nog toe, maar laat je daardoor niet van de wijs brengen. Met alle kennis die je tot nog toe hebt opgedaan en met nog enkele tips kom je er wel uit.
\nDeze oefening luidt: Schrijf een programma dat de volgende handelingen met breuken kan uitvoeren:
\n– twee breuken optellen
\n– twee breuken aftrekken
\n– twee breuken vermenigvuldigen
\n– twee breuken delen
\n– een breuk vereenvoudigen
\n– een breuk decimaal kan maken.<\/p>\n

Tevens moet het programma in staat zijn om optioneel de resultaten in een bestand op schijf te bewaren.<\/p>\n

E\u00e9n en ander moet in een menu aan de gebruiker worden aangeboden.<\/p>\n

Tips:
\nGebruik een record-type TBreuk om een breuk te representeren.
\nOm breuken te vereenvoudigen is het handig om de ggd van teller en noemer te bepalen, schrijf daartoe een functie Ggd.
\nHierbij kun je gebruik maken van het algoritme van Euclides:
\n1. Bepaal de gehele deling (div) en rest (mod) van teller en noemer,
\n2. Als de rest 0 is, dan is de ggd=noemer,
\n3. Anders is de ggd= ggd van de noemer en de rest (dus recursief).
\nOm een breuk in te lezen maak je gebruik van een procedure die teller en noemer apart vraagt.
\nOm een breuk op het scherm (of in het bestand) te schrijven maak je gebruik van een functie.
\nDaarbij is het handig om een functie IntToStr te hebben die een integer omzet naar een string.
\nMaak die functie en maak daarbij gebruik van de ingebouwde functie chr([waarde]), die [waarde] omzet naar een char met ascii-waarde [waarde] (‘0’=48, ‘9’=57). [Antwoord<\/a>]\n

[Recursie<\/a>] <– –> [Pointers<\/a>]\n","protected":false},"excerpt":{"rendered":"

We hebben al een aantal keer (gedwongen) gebruik gemaakt van een type-declaratie voor strings. Pascal kent het principe van zelfgemaakte types. In hoofdstuk 8 (of 9) hebben we hier een paar voorbeelden van gezien. In dit hoofdstuk gaan we ons bezig houden met gestructureerde types. Deze versie van Pascal kent twee gestructureerde types, nl. de\u00a0array\u00a0en […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":185,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"templates\/template-full-width.php","meta":{"_lmt_disableupdate":"","_lmt_disable":"","footnotes":""},"class_list":["post-210","page","type-page","status-publish","hentry"],"yoast_head":"\nGestructureerde types - Wiskunst<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/wiskunst.nl\/index.php\/programmeren1\/programmeren\/gestructureerde-types\/\" \/>\n<meta property=\"og:locale\" content=\"nl_NL\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Gestructureerde types - Wiskunst\" \/>\n<meta property=\"og:description\" content=\"We hebben al een aantal keer (gedwongen) gebruik gemaakt van een type-declaratie voor strings. Pascal kent het principe van zelfgemaakte types. In hoofdstuk 8 (of 9) hebben we hier een paar voorbeelden van gezien. In dit hoofdstuk gaan we ons bezig houden met gestructureerde types. Deze versie van Pascal kent twee gestructureerde types, nl. de\u00a0array\u00a0en […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/wiskunst.nl\/index.php\/programmeren1\/programmeren\/gestructureerde-types\/\" \/>\n<meta property=\"og:site_name\" content=\"Wiskunst\" \/>\n<meta property=\"article:modified_time\" content=\"2022-01-24T08:36:55+00:00\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Geschatte leestijd\" \/>\n\t<meta name=\"twitter:data1\" content=\"10 minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/wiskunst.nl\\\/index.php\\\/programmeren1\\\/programmeren\\\/gestructureerde-types\\\/\",\"url\":\"https:\\\/\\\/wiskunst.nl\\\/index.php\\\/programmeren1\\\/programmeren\\\/gestructureerde-types\\\/\",\"name\":\"Gestructureerde types - Wiskunst\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/wiskunst.nl\\\/#website\"},\"datePublished\":\"2022-01-20T14:55:25+00:00\",\"dateModified\":\"2022-01-24T08:36:55+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/wiskunst.nl\\\/index.php\\\/programmeren1\\\/programmeren\\\/gestructureerde-types\\\/#breadcrumb\"},\"inLanguage\":\"nl-NL\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/wiskunst.nl\\\/index.php\\\/programmeren1\\\/programmeren\\\/gestructureerde-types\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/wiskunst.nl\\\/index.php\\\/programmeren1\\\/programmeren\\\/gestructureerde-types\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/wiskunst.nl\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programmeren\",\"item\":\"https:\\\/\\\/wiskunst.nl\\\/index.php\\\/programmeren1\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Programmeren met Pascal\",\"item\":\"https:\\\/\\\/wiskunst.nl\\\/index.php\\\/programmeren1\\\/programmeren\\\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Gestructureerde types\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/wiskunst.nl\\\/#website\",\"url\":\"https:\\\/\\\/wiskunst.nl\\\/\",\"name\":\"Wiskunst\",\"description\":\"2\u221e\u2227>\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/wiskunst.nl\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"nl-NL\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Gestructureerde types - Wiskunst","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/wiskunst.nl\/index.php\/programmeren1\/programmeren\/gestructureerde-types\/","og_locale":"nl_NL","og_type":"article","og_title":"Gestructureerde types - Wiskunst","og_description":"We hebben al een aantal keer (gedwongen) gebruik gemaakt van een type-declaratie voor strings. Pascal kent het principe van zelfgemaakte types. In hoofdstuk 8 (of 9) hebben we hier een paar voorbeelden van gezien. In dit hoofdstuk gaan we ons bezig houden met gestructureerde types. Deze versie van Pascal kent twee gestructureerde types, nl. de\u00a0array\u00a0en […]","og_url":"https:\/\/wiskunst.nl\/index.php\/programmeren1\/programmeren\/gestructureerde-types\/","og_site_name":"Wiskunst","article_modified_time":"2022-01-24T08:36:55+00:00","twitter_card":"summary_large_image","twitter_misc":{"Geschatte leestijd":"10 minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/wiskunst.nl\/index.php\/programmeren1\/programmeren\/gestructureerde-types\/","url":"https:\/\/wiskunst.nl\/index.php\/programmeren1\/programmeren\/gestructureerde-types\/","name":"Gestructureerde types - Wiskunst","isPartOf":{"@id":"https:\/\/wiskunst.nl\/#website"},"datePublished":"2022-01-20T14:55:25+00:00","dateModified":"2022-01-24T08:36:55+00:00","breadcrumb":{"@id":"https:\/\/wiskunst.nl\/index.php\/programmeren1\/programmeren\/gestructureerde-types\/#breadcrumb"},"inLanguage":"nl-NL","potentialAction":[{"@type":"ReadAction","target":["https:\/\/wiskunst.nl\/index.php\/programmeren1\/programmeren\/gestructureerde-types\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/wiskunst.nl\/index.php\/programmeren1\/programmeren\/gestructureerde-types\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/wiskunst.nl\/"},{"@type":"ListItem","position":2,"name":"Programmeren","item":"https:\/\/wiskunst.nl\/index.php\/programmeren1\/"},{"@type":"ListItem","position":3,"name":"Programmeren met Pascal","item":"https:\/\/wiskunst.nl\/index.php\/programmeren1\/programmeren\/"},{"@type":"ListItem","position":4,"name":"Gestructureerde types"}]},{"@type":"WebSite","@id":"https:\/\/wiskunst.nl\/#website","url":"https:\/\/wiskunst.nl\/","name":"Wiskunst","description":"2\u221e\u2227>","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/wiskunst.nl\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"nl-NL"}]}},"_links":{"self":[{"href":"https:\/\/wiskunst.nl\/index.php\/wp-json\/wp\/v2\/pages\/210","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/wiskunst.nl\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/wiskunst.nl\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/wiskunst.nl\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/wiskunst.nl\/index.php\/wp-json\/wp\/v2\/comments?post=210"}],"version-history":[{"count":7,"href":"https:\/\/wiskunst.nl\/index.php\/wp-json\/wp\/v2\/pages\/210\/revisions"}],"predecessor-version":[{"id":541,"href":"https:\/\/wiskunst.nl\/index.php\/wp-json\/wp\/v2\/pages\/210\/revisions\/541"}],"up":[{"embeddable":true,"href":"https:\/\/wiskunst.nl\/index.php\/wp-json\/wp\/v2\/pages\/185"}],"wp:attachment":[{"href":"https:\/\/wiskunst.nl\/index.php\/wp-json\/wp\/v2\/media?parent=210"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}