|
Structuren
Een beschrijving van de structuur
Een structuur is een door de gebruiker zelf gedefinieerd datatype. Je
hebt als programmeur de mogelijkheid een datatype te definiëren dat
aanmerkelijk complexer is als de datatypes die we tot nu toe in de
cursus gebruikt hebben. Een structuur is opgebouwd uit variabelen van
datatypes die eerder werden gedefinieerd. Anders gezegd, een structuur
is een groepering van aan elkaar gerelateerde gegevens. Structuren kunnen
het leven van de programmeur bijzonder veraangenamen.
Laten we eens naar een voorbeeld gaan kijken.
Bestudeer daarom het programma STRUCT1.rex.
<![CDATA[
/* REXX */
ROW = 1 /* definitie structuur element */
COLUMN = 2
LENGTH = 3
VELD.1.ROW = 6
VELD.1.COLUMN = 12
VELD.1.LENGTH = 20
VELD.2.LENGTH = 32
VELD.2.COLUMN = 12
VELD.2.ROW = VELD.1.ROW + 2
Say 'VELD 1 staat op rij 'VELD.1.ROW', kolom 'VELD.1.COLUMN,
'en is 'VELD.1.LENGTH' tekens lang'
Say 'VELD 2 staat op rij 'VELD.2.ROW', kolom 'VELD.2.COLUMN,
'en is 'VELD.2.LENGTH' tekens lang'
Exit 0
]]>
Het programma begint met de definitie van een aantal structuur elementen,
d.w.z. koppelt een naam aan een structuur nummer. Deze vormen de
componenten van de structuur. VELD is nu een variabele bestaande
uit drie componenten, ROW, COLUMN en LENGTH.
Elk van deze drie componenten zijn gerelateerd aan VELD en kunnen
gegevens opslaan afhankelijk van hun type. Van de variabele VELD
zijn meerdere exemplaren mogelijk. In het voorbeeld is voor twee exemplaren
gekozen. Er is gekozen om het exemplaar nummer op nivo twee te zetten en de
structuur element op nivo drie.
Laten we eens wat nauwkeuriger naar de variabele VELD.1
kijken. De drie componenten waaruit deze structuur is opgebouwd, zijn
alle integers en kunnen in principe overal toegepast worden in een REXX
programma waar een gewone integer gebruikt mag worden. Je
kunt er dus mee rekenen, afdrukken, in- of uitvoeren, enz. Het probleem
is nu hoe een component van een structuur (ook wel structuur member
genoemd) aan te wijzen in een programma. We doen dit door beide namen
te gebruiken, dat wil zeggen structuur naam plus component naam met een
puntje ertussen. Dus VELD.1.LENGTH is de naam van de
variabele die de lengte component van het eerste veld aanwijst. Het is
niet toegestaan aan de component naam alleen te refereren, omdat de
interpreter dan niet kan bepalen om welke component het gaat.
Het programma kent vervolgens aan elk van de drie componenten van
VELD.1 een waarde toe. De componenten van VELD.2
krijgen in omgekeerde volgorde een waarde, om aan te tonen dat de
volgorde waarin structuur members een waarde krijgen niet relevant is.
Nu alle variabelen een waarde hebben, kunnen we er iets mee doen. Om
het eerste voorbeeld eenvoudig te houden, werd alleen met de rij van
het tweede veld een berekening uitgevoerd en worden de variabelen
slechts gebruikt om af te drukken. Het Say statement
vertoont geen echte bijzonderheden. De samengestelde naam van de
variabelen wordt gebruikt, omdat dit de enige geldige manier is om ze
aan te wijzen.
Structuren zijn bijzonder handig om gegevens te structureren en maken
het je makkelijker om programma's te schrijven en te begrijpen. Dit
eerste voorbeeld is te eenvoudig om je de kracht ervan te laten zien.
De volgende voorbeelden zullen je al wat meer inzicht geven en zijn een
goede basis om het Totaal Programma te doorgronden.
Compileer en test het programma.
Een tabel van structuren
Bestudeer het programma STRUCT2.rex. Dit programma bevat dezelfde
structuur als het vorige, echter deze keer declareren we 8 velden in de
vorm van een tabel. Dit programma bevat dus 8 maal 3 is 24 variabelen,
die alle een integer waarde kunnen bevatten. Tevens wordt een lus
variabele gedeclareerd, om via een iteratie de structuur te vullen.
<![CDATA[
/* REXX */
ROW = 1 /* definitie structuur element */
COLUMN = 2
LENGTH = 3
Do i=1 To 8
VELD.i.ROW = i + 4
VELD.i.COLUMN = 12
VELD.i.LENGTH = 20
End
Do i=1 To 8
Say 'VELD 'i': ',
'rij 'Right(VELD.i.ROW,2)', ',
'kolom 'Right(VELD.i.COLUMN,2)', ',
'lengte 'Right(VELD.i.LENGTH,2)
End
Exit 0
]]>
De for lus wordt 8 keer doorlopen en in elke stap van de iteratie wordt
aan de drie componenten van een veld een waarde toegekend. Op deze
manier kan de interne administratie van het Yahtzee spel georganiseerd
worden. Hier wordt geadministreerd op welke regel en welke kolom van
het scherm een veld begint en wat de maximale lengte is.
In de volgende drie statements wordt aan sommige lengte componenten een
andere waarde gegeven. Dit is om te laten zien hoe dat moet. In REXX is
het niet mogelijk een structuur via een toekenning te vullen vanuit een
andere structuur.
Tenslotte worden alle gegenereerde waarden middels een iteratie
afgedrukt. Compileer en test dit programma.
Een voorbeeld programma
Bestudeer nu het programma ZEGTYD.rex. Dit programma bevat heel veel
elementen van hetgeen je tot op heden hebt bestudeerd. Alle onderwerpen
in een klein programma. De bedoeling van het programma is dat het de
systeemtijd afdrukt als ware het gesproken tekst. Een conversie van
numeriek naar uitgesproken tekst als het ware. Laten we er maar eens
naar kijken.
<![CDATA[
/* REXX */
W = 'twaalf een twee drie vier vijf zes zeven',
'acht negen tien elf twaalf dertien veertien'
Parse Value Time() With HH ':' MM ':' .
HH = HH + 1
Call CharOut,'Het is '
Select
When (MM < 1) Then Call CharOut,'precies 'Word(W,HH//12)' uur'
When (MM < 2) Then Call CharOut,'een minuut over 'Word(W,HH//12)
When (MM < 15) Then Call CharOut,Word(W,MM+1)' minuten over 'Word(W,HH//12)
When (MM < 16) Then Call CharOut,'kwart over 'Word(W,HH//12)
When (MM < 29) Then Call CharOut,Word(W,31-MM)' minuten voor half 'Word(W,HH//12+1)
When (MM < 30) Then Call CharOut,'een minuut voor half 'Word(W,HH//12+1)
When (MM < 31) Then Call CharOut,'half 'Word(W,HH//12+1)
When (MM < 32) Then Call CharOut,'een minuut over half 'Word(W,HH//12+1)
When (MM < 45) Then Call CharOut,Word(W,MM-29)' minuten over half 'Word(W,HH//12+1)
When (MM < 46) Then Call CharOut,'kwart voor 'Word(W,HH//12+1)
When (MM < 59) Then Call CharOut,Word(W,61-MM)' minuten voor 'Word(W,HH//12+1)
Otherwise Call CharOut,'een minuut voor 'Word(W,HH//12+1)
End
Say '...'
Exit 0
]]>
Er wordt een REXX string-tabel gedeclareerd.
De strings zijn de woorden van de uren. De subscript op de tabel komt
overeen met het uur of de minuut; het element komt overeen met het uur
of de minuut plus 1. Uur nul is uur twaalf is element 1 is subscript 1.
Minuut veertien is element 15 is subscript 15.
In het hoofdprogramma volgt de declaratie van twee integer
hulpvariabelen HH en MM, voor respectievelijk de
uren en minuten.
Middels functie Time() wordt de systeemtijd opgehaald.
Van deze tijd hebben we alleen uur en minuut nodig. Middels de
Parse Value instructie worden die onderdelen eruit gehaald.
De wijzerplaat wordt nu in een aantal specifieke delen geknipt en van
elk deel de uitspraak bepaald. Een Select statement zou hier
op zijn plaats zijn, en is dus ook toegepast.
De variabele W is gebruikt als een eendimensionale tabel van
strings. Met behulp van de CharOut functie en de Word functie
wordt een van toepassing zijnde tekst afgedrukt. Het programma sluit af met
het afdrukken van drie puntjes en een NewLine karakter.
Compileer en test dit programma.
|
