De naam "computer" komt uit het Engels ("to compute" = iets uitrekenen). De eerste computers waren dus mensen die in hun hoofd dingen uitrekenden.
De dataopslag gebeurde met een potlood op een blaadje papier.
Wij schrijven en tellen dingen van links naar rechts: 1, 2, 3, 4.
Maar onze getallen komen uit het Arabisch, en daar schrijven ze van rechts naar links: 87654321.
Het geheugen van een computer bestaat uit een hele lange reeks van bits. Je kunt daarmee natuurlijk maar tot 2 tellen, dus moet je die bits gaan groeperen. De eerste computers gebruikten Binary-Coded Decimal (BCD), daarbij gebruik je setjes van 4 bits om de (decimale) getallen van 0 tot en met 9 op te slaan.
Daar iedere computer deze bits in andere setjes indeelde (bytes van 4 tot 9 bits waren populair), is dit op een gegeven moment gestandaardiseerd op 8 bits per byte.
Je kunt dan een BCD getal op twee verschillende manieren opslaan, al naar gelang je het geheugen van links naar rechts of van rechts naar links nummert:
Dit noemen we Endianness. Van links naar rechts is Big-endian, van rechts naar links Little-endian. Voor getallen is het tweede handiger, voor tekst het eerste.
De hoeveelheid bits die een computer in 1 keer kon verwerken werd de woordgrootte genoemd. Populaire groottes in het begin waren 36 en 48 bit, maar een heleboel andere groottes werden ook gebruikt, van 4 tot 60 bit. Omdat dat verwarrend was, is dit na de komst van de microcomputer gestandaardiseerd op 16 bit.
Om een getal te kunnen onthouden, bijvoorbeeld een teller, heb je drie dingen nodig:
De naam is eigenlijk alleen voor de mensen die er mee werken belangrijk, want de computer denkt alleen in getallen. Hij moet weten dat het getal begint op locatie 3701, de lengte in bytes en welke endianness hij moet gebruiken. De benaming "pointer" komt natuurlijk van "to point", aanwijzen.
Echter, de eerste locatie heeft de waarde 0, en je kunt geen negatieve locaties hebben. Dus, het nummer van de eerste waarde is 0. Dit noemt men ook cardinale getallen.
We hebben nu dus al de volgende datatypes:
1. Geschreven tekst (analoog)
2. Bits
3. Bytes (tegenwoordig 8 bits)
4. Woorden (tegenwoordig 16 bits)
5. Binary-Coded Decimal (4 bits)
6. Positieve getallen (tellen vanaf 1, variabele lengte, meestal in woorden)
7. Pointers/Cardinalen (tellen vanaf 0, variabele lengte, in woorden)
Natuurlijk willen we ook negatieve getallen kunnen gebruiken, die aan dezelfde rekenregels voldoen als positieve getallen. Dat doen we door een positief getal te nemen, alle bits te inverteren en er 1 bij op te tellen voor het negatieve getal. Het hoogste bit (aan de linkerkant, dus) geeft dan aan of het getal positief of negatief is.
In het begin werden computers veel gebruikt door banken, die in centen tellen. Je moet dan 2 getallen achter de komma hebben (plus nog 1 of 2 extra om afrondingsfouten te voorkomen). Het is dan het eenvoudigste om alle getallen met 1000 of 10.000 te vermenigvuldigen. Dit noemen we vaste-komma getallen of valuta (fixed-point). Ook kunnen we een deel van het getal gebruiken om te bepalen waar de komma staat, dan krijgen we gebroken getallen (floating point).
Dat ziet er dan bijvoorbeeld zo uit:
Die komen er dus nog bij:
8: Gehele getallen (ook negatief, variabele lengte, meestal in woorden)
9: Valuta (fixed-point, variabele lengte, in woorden)
10: Gebroken getallen (floating point, variabele lengte, in woorden)
En dan hebben we tekst.
De eerste, populaire, elektronische typemachines gebruikten een wieltje
of bolletje
met daarop een set afdrukbare tekens. Je slaat het bolletje (of met een hamertje een teken op het wieltje) tegen het lint en het papier en je hebt een letter geprint.
Je kunt dan gewoon het nummer van het teken opslaan in het geheugen. Maar omdat de tekens op die wieltjes/bolletjes niet altijd op dezelfde plaats stonden, was dat niet erg uitwisselbaar. Dit is uiteindelijk gestandaardiseerd op ASCII, dat 8 bits per teken gebruikte (en ook de standaard grootte van een Byte bepaalde).
Maar hiermee kun je natuurlijk lang niet alle tekens opslaan en afdrukken. Verschillende fabrikanten hebben daarna de grootte van 1 karakter opgerekt naar 16 bits. Deze nieuwe standaarden waren niet compatibel met elkaar. En, omdat 16 bits ook niet genoeg was, gingen sommigen dit oprekken tot 32 bits per teken, terwijl anderen dat te lang vonden en besloten een variabel aantal bytes per karakter te gaan gebruiken (Multi-Byte Character Sets).
Omdat dit toch wel heel lastig uitwisselbaar was, is ondertussen de Unicode werkgroep opgericht. Eerst hebben die de 16-bit codes gestandaardiseerd (UTF-16) en later ook de rest. Het is een tijdje zo geweest, dat je ieder mogelijk teken kon opslaan als een 32-bit getal (UTF-32). Maar helaas is dat tegenwoordig niet meer het geval.
Er verschenen steeds meer tekens uit verschillende talen die er wel hetzelfde uitzagen, maar iets anders betekenden. Wil je die opslaan als 1 enkel teken, of als meerdere? En er zijn talen waarbij je leestekens toe kunt voegen aan de meeste tekens, om zo hun betekenis te veranderen, zoals umlauts. In sommige talen worden karakters op elkaar geplakt tot woorden. Ga je dan alleen die tekens, leestekens en deelwoorden opslaan, of alle samengestelde tekens?
Uiteindelijk heeft het Unicode comité er voor gekozen om het allemaal toe te staan: veel gecombineerde tekens zijn toegevoegd, maar niet allemaal. En je mag ook het basisteken opgeven, samen met een set van leestekens die je daar aan toevoegt. Of de deelwoorden die je op elkaar plakt. En daar sommige van die leestekens en deelwoorden veel op elkaar lijken, kun je dat op verschillende manieren doen.( Zie ook dit.) Je kunt daardoor een heleboel tekens op verschillende manieren opslaan, die geen relatie met elkaar hebben. Het is dus vaak nog steeds moeilijk uitwisselbaar.
Omdat deze tekens erg lang kunnen worden en een variabel aantal bytes in beslag nemen, is daar ook een standaard voor gemaakt: UTF-8.
Aan de ene kant moet je UTF-8 gebruiken als je alle tekens wilt kunnen opslaan, maar aan de andere kant is er bijvoorbeeld geen manier om die consistent te sorteren, of zelfs maar de individuele tekens met zekerheid te kunnen herkennen. Ook moet je voor iedere bewerking vanaf het begin alle tekens doorlopen. Als je er wel gemakkelijk mee wilt kunnen werken is UTF-32 de beste keus, maar die is weer incompleet.
Om deze tekens te combineren tot woorden en tekst, zetten we ze achter elkaar in een array. Dat noemen we een String.
We hebben nu dus ook:
11. Ongestandaardiseerde tekens (variabel aantal bits)
12. ASCII (8 bits)
13. Fabrikant-specifieke vaste lengte tekensets (8, 16 en 32 bits)
14. Fabrikant-specifieke Multi-byte sets (variabele lengte, in bytes of woorden)
15. Unicode (geen standaard bitlengte)
16. UTF-16 (16 bits)
17: UTF-32 (32 bits)
18. UTF-8 (variabele lengte, in bytes)
19. String (variabele lengte, in tekens of bytes)
Dan komen we nu bij de structuren.
De eenvoudigste structuur is een byte: die heeft alleen een adres en een waarde. Als je getal of tekenreeks langer worden, moet je ook de endianness en het aantal bytes gaan specificeren. Deze combinatie van eigenschappen noemen we een datatype. Je kunt deze ook weer combineren, bijvoorbeeld door ze in een array te stoppen: je hebt dan ook daarvan het aantal nodig.
Je kunt hier complexere types van maken, door er een aantal achter elkaar te plakken. Deze hoeven niet allemaal van hetzelfde type te zijn. Je kunt bijvoorbeeld een volgnummer (Cardinaal) combineren met een waarde (gebroken getal). We noemen dit een record.
Al de gegevens die je daarvoor nodig hebt, bepalen het type data. En je kunt dat heel complex maken. Dit zijn variabelen: types met een variabele waarde.
Als je een verzameling variabelen op wilt slaan, kun je dat op verschillende manieren doen. De simpelste manier is om ze gewoon achter elkaar te plakken in een array. Maar dat werkt eigenlijk alleen goed als je van te voren al weet hoeveel je er gaat hebben. Als je ook nieuwe gegevens wilt toevoegen en/of ze wilt sorteren, dan is een array niet zo handig. Bijvoorbeeld, als hij vol is, moet je de inhoud kopieren naar een nieuw, groter array. Je hebt dus veel ruimte nodig. En als je gedeeltes verwijderd moet je alles daarboven naar beneden schuiven.
Databases lossen dat gedeeltelijk op door reeksen kleinere arrays en indexen te gebruiken. Je voegt aan ieder blok dan een pointer toe die naar het volgende blok wijst. En dat kun je natuurlijk ook doen met alle individuele records. Dat noemen we een gelinkte lijst en dat ziet er zo uit:
Om het dan snel te kunnen vinden maak je een index:
En je zou ook een index kunnen maken met de namen op alfabetische volgorde.
Om te bepalen hoe lang een lijst of array is, kun je twee dingen doen: je maakt het laatste element (of de pointer die daar naar wijst) 0, of je zet de lengte in het eerste element. Beide manieren hebben zo hun voor- en nadelen. En je kunt in een gelinkte lijst ook een pointer opnemen naar het vorige element, dan kun je er in twee richtingen doorheen.
Nou werden programma's nogal groot en onoverzichtelijk en hebben we daar nog een nieuw type opslag aan toegevoegd: objecten. Daarbij worden zowel de gegevens als de programmacode gecombineerd. We noemen zo'n datatype tegenwoordig een class. Dat ziet er als volgt uit:
Die functies (en de definities daarvan) noemen we methodes en je hoeft ze natuurlijk slechts eenmalig op te slaan. En je kunt een class uitbreiden door er nieuwe variabelen of functies achteraan te plakken.
Je gebruikt een methode door hem als eerste parameter een pointer naar het datablok te geven, zoals:
(Dat betekent: de inhoud van (de inhoud van de pointer naar Artikel + de offset naar de methode) aanroepen als functie met de parameters 11634 en "Badhanddoek".)
Om het wat leesbaarder te maken:
Of om het nog mooier te maken:
Het nummer (11634) is dan de pointer naar het record met daarin de object data. En alle bovenstaande voorbeelden betekenen hetzelfde, het hangt van de programmeertaal af welke je moet gebruiken. En er zijn meer mogelijkheden.
1 van de mooie dingen van zulke objecten is dus dat je er dingen aan toe kunt voegen en zo nieuwe objecten kunt maken. Je kunt (meestal) ook dingen verwijderen of overschrijven.
We hebben in de bovenstaande class bijvoorbeeld de functie AantalVerkocht, die de opgegeven hoeveelheid aftrekt van Aantal. Maar nu willen we een nieuwe class maken met een nieuwe functie die controleert of het totaal dan niet negatief is:
Dat is natuurlijk wel verwarrend, want je hebt nu twee keer een methode met dezelfde naam. Als het mogelijk moet zijn om bestaande methodes te kunnen wijzigen, kun je er beter pointers van maken:
Je kunt dan ook de functie AantalVerkocht in de class Artikel vervangen door de nieuwe versie, of voor de nieuwe class een kopietje maken en het daar vervangen:
Het hangt af van de programmeertaal hoe dat precies werkt en wat je mogelijkheden zijn. En als je het anders wilt, kun je het natuurlijk ook zelf maken.
En die kunnen we dus als laatste toevoegen aan onze lijst:
20. Arrays (variabele lengte)
21. Records (variabele lengte)
22. Gelinkte lijsten (variabele lengte)
23. Objecten of Classes (variabele lengte)
En natuurlijk kun je al deze dingen weer verder combineren.
De dataopslag gebeurde met een potlood op een blaadje papier.
Wij schrijven en tellen dingen van links naar rechts: 1, 2, 3, 4.
Maar onze getallen komen uit het Arabisch, en daar schrijven ze van rechts naar links: 87654321.
Het geheugen van een computer bestaat uit een hele lange reeks van bits. Je kunt daarmee natuurlijk maar tot 2 tellen, dus moet je die bits gaan groeperen. De eerste computers gebruikten Binary-Coded Decimal (BCD), daarbij gebruik je setjes van 4 bits om de (decimale) getallen van 0 tot en met 9 op te slaan.
Daar iedere computer deze bits in andere setjes indeelde (bytes van 4 tot 9 bits waren populair), is dit op een gegeven moment gestandaardiseerd op 8 bits per byte.
Je kunt dan een BCD getal op twee verschillende manieren opslaan, al naar gelang je het geheugen van links naar rechts of van rechts naar links nummert:
code:
1
2
3
4
5
| Geheugenplaats: 1, 2, 3, 4 of Geheugenplaats: 4, 3, 2, 1 <-- begin hier, het zijn getallen Waarde: 87 65 43 21 |
Dit noemen we Endianness. Van links naar rechts is Big-endian, van rechts naar links Little-endian. Voor getallen is het tweede handiger, voor tekst het eerste.
De hoeveelheid bits die een computer in 1 keer kon verwerken werd de woordgrootte genoemd. Populaire groottes in het begin waren 36 en 48 bit, maar een heleboel andere groottes werden ook gebruikt, van 4 tot 60 bit. Omdat dat verwarrend was, is dit na de komst van de microcomputer gestandaardiseerd op 16 bit.
Om een getal te kunnen onthouden, bijvoorbeeld een teller, heb je drie dingen nodig:
code:
1
2
| Teller1 staat op locatie 3701 en is 3. Naam Pointer Waarde |
De naam is eigenlijk alleen voor de mensen die er mee werken belangrijk, want de computer denkt alleen in getallen. Hij moet weten dat het getal begint op locatie 3701, de lengte in bytes en welke endianness hij moet gebruiken. De benaming "pointer" komt natuurlijk van "to point", aanwijzen.
Echter, de eerste locatie heeft de waarde 0, en je kunt geen negatieve locaties hebben. Dus, het nummer van de eerste waarde is 0. Dit noemt men ook cardinale getallen.
We hebben nu dus al de volgende datatypes:
1. Geschreven tekst (analoog)
2. Bits
3. Bytes (tegenwoordig 8 bits)
4. Woorden (tegenwoordig 16 bits)
5. Binary-Coded Decimal (4 bits)
6. Positieve getallen (tellen vanaf 1, variabele lengte, meestal in woorden)
7. Pointers/Cardinalen (tellen vanaf 0, variabele lengte, in woorden)
Natuurlijk willen we ook negatieve getallen kunnen gebruiken, die aan dezelfde rekenregels voldoen als positieve getallen. Dat doen we door een positief getal te nemen, alle bits te inverteren en er 1 bij op te tellen voor het negatieve getal. Het hoogste bit (aan de linkerkant, dus) geeft dan aan of het getal positief of negatief is.
code:
1
2
3
| 0010 <- 2 1101 <- inverteren 1110 <- +1, maakt -2 |
In het begin werden computers veel gebruikt door banken, die in centen tellen. Je moet dan 2 getallen achter de komma hebben (plus nog 1 of 2 extra om afrondingsfouten te voorkomen). Het is dan het eenvoudigste om alle getallen met 1000 of 10.000 te vermenigvuldigen. Dit noemen we vaste-komma getallen of valuta (fixed-point). Ook kunnen we een deel van het getal gebruiken om te bepalen waar de komma staat, dan krijgen we gebroken getallen (floating point).
Dat ziet er dan bijvoorbeeld zo uit:
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| Bit 15 negatief 14 \ 13 | de plaats van de komma in het getal 12 / 11 \ 10 | 09 | 08 | 07 | 06 | waarde 05 | 04 | 03 | 02 | 01 | 00 / |
Die komen er dus nog bij:
8: Gehele getallen (ook negatief, variabele lengte, meestal in woorden)
9: Valuta (fixed-point, variabele lengte, in woorden)
10: Gebroken getallen (floating point, variabele lengte, in woorden)
En dan hebben we tekst.
De eerste, populaire, elektronische typemachines gebruikten een wieltje
of bolletje
met daarop een set afdrukbare tekens. Je slaat het bolletje (of met een hamertje een teken op het wieltje) tegen het lint en het papier en je hebt een letter geprint.
Je kunt dan gewoon het nummer van het teken opslaan in het geheugen. Maar omdat de tekens op die wieltjes/bolletjes niet altijd op dezelfde plaats stonden, was dat niet erg uitwisselbaar. Dit is uiteindelijk gestandaardiseerd op ASCII, dat 8 bits per teken gebruikte (en ook de standaard grootte van een Byte bepaalde).
Maar hiermee kun je natuurlijk lang niet alle tekens opslaan en afdrukken. Verschillende fabrikanten hebben daarna de grootte van 1 karakter opgerekt naar 16 bits. Deze nieuwe standaarden waren niet compatibel met elkaar. En, omdat 16 bits ook niet genoeg was, gingen sommigen dit oprekken tot 32 bits per teken, terwijl anderen dat te lang vonden en besloten een variabel aantal bytes per karakter te gaan gebruiken (Multi-Byte Character Sets).
Omdat dit toch wel heel lastig uitwisselbaar was, is ondertussen de Unicode werkgroep opgericht. Eerst hebben die de 16-bit codes gestandaardiseerd (UTF-16) en later ook de rest. Het is een tijdje zo geweest, dat je ieder mogelijk teken kon opslaan als een 32-bit getal (UTF-32). Maar helaas is dat tegenwoordig niet meer het geval.
Er verschenen steeds meer tekens uit verschillende talen die er wel hetzelfde uitzagen, maar iets anders betekenden. Wil je die opslaan als 1 enkel teken, of als meerdere? En er zijn talen waarbij je leestekens toe kunt voegen aan de meeste tekens, om zo hun betekenis te veranderen, zoals umlauts. In sommige talen worden karakters op elkaar geplakt tot woorden. Ga je dan alleen die tekens, leestekens en deelwoorden opslaan, of alle samengestelde tekens?
Uiteindelijk heeft het Unicode comité er voor gekozen om het allemaal toe te staan: veel gecombineerde tekens zijn toegevoegd, maar niet allemaal. En je mag ook het basisteken opgeven, samen met een set van leestekens die je daar aan toevoegt. Of de deelwoorden die je op elkaar plakt. En daar sommige van die leestekens en deelwoorden veel op elkaar lijken, kun je dat op verschillende manieren doen.( Zie ook dit.) Je kunt daardoor een heleboel tekens op verschillende manieren opslaan, die geen relatie met elkaar hebben. Het is dus vaak nog steeds moeilijk uitwisselbaar.
Omdat deze tekens erg lang kunnen worden en een variabel aantal bytes in beslag nemen, is daar ook een standaard voor gemaakt: UTF-8.
Aan de ene kant moet je UTF-8 gebruiken als je alle tekens wilt kunnen opslaan, maar aan de andere kant is er bijvoorbeeld geen manier om die consistent te sorteren, of zelfs maar de individuele tekens met zekerheid te kunnen herkennen. Ook moet je voor iedere bewerking vanaf het begin alle tekens doorlopen. Als je er wel gemakkelijk mee wilt kunnen werken is UTF-32 de beste keus, maar die is weer incompleet.
Om deze tekens te combineren tot woorden en tekst, zetten we ze achter elkaar in een array. Dat noemen we een String.
We hebben nu dus ook:
11. Ongestandaardiseerde tekens (variabel aantal bits)
12. ASCII (8 bits)
13. Fabrikant-specifieke vaste lengte tekensets (8, 16 en 32 bits)
14. Fabrikant-specifieke Multi-byte sets (variabele lengte, in bytes of woorden)
15. Unicode (geen standaard bitlengte)
16. UTF-16 (16 bits)
17: UTF-32 (32 bits)
18. UTF-8 (variabele lengte, in bytes)
19. String (variabele lengte, in tekens of bytes)
Dan komen we nu bij de structuren.
De eenvoudigste structuur is een byte: die heeft alleen een adres en een waarde. Als je getal of tekenreeks langer worden, moet je ook de endianness en het aantal bytes gaan specificeren. Deze combinatie van eigenschappen noemen we een datatype. Je kunt deze ook weer combineren, bijvoorbeeld door ze in een array te stoppen: je hebt dan ook daarvan het aantal nodig.
Je kunt hier complexere types van maken, door er een aantal achter elkaar te plakken. Deze hoeven niet allemaal van hetzelfde type te zijn. Je kunt bijvoorbeeld een volgnummer (Cardinaal) combineren met een waarde (gebroken getal). We noemen dit een record.
Al de gegevens die je daarvoor nodig hebt, bepalen het type data. En je kunt dat heel complex maken. Dit zijn variabelen: types met een variabele waarde.
Als je een verzameling variabelen op wilt slaan, kun je dat op verschillende manieren doen. De simpelste manier is om ze gewoon achter elkaar te plakken in een array. Maar dat werkt eigenlijk alleen goed als je van te voren al weet hoeveel je er gaat hebben. Als je ook nieuwe gegevens wilt toevoegen en/of ze wilt sorteren, dan is een array niet zo handig. Bijvoorbeeld, als hij vol is, moet je de inhoud kopieren naar een nieuw, groter array. Je hebt dus veel ruimte nodig. En als je gedeeltes verwijderd moet je alles daarboven naar beneden schuiven.
Databases lossen dat gedeeltelijk op door reeksen kleinere arrays en indexen te gebruiken. Je voegt aan ieder blok dan een pointer toe die naar het volgende blok wijst. En dat kun je natuurlijk ook doen met alle individuele records. Dat noemen we een gelinkte lijst en dat ziet er zo uit:
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| MijnRecord ---------- Serienummer (1 woord) Aantal (1 woord) Prijs (1 woord) Pointer naar String met naam (1 woord) MijnLijst ----------- MijnRecord Pointer naar volgende record Adres: Inhoud 0051: Record1 [0001 5 3,99 1001="Handzeep"] .. 0055: Pointer naar volgende record = 0106 0101: Record 3 [0017 0 4,99 1099="Handdoek"] .. 0105: Pointer naar volgende record = 0 (geen volgende record) 0106: Record 2 [0003 19 8,95 1016="Koekenpan"] .. 0110: Pointer naar volgende record = 0101 |
Om het dan snel te kunnen vinden maak je een index:
code:
1
2
3
| Record1 = 0051 Record2 = 0106 Record3 = 0101 |
En je zou ook een index kunnen maken met de namen op alfabetische volgorde.
Om te bepalen hoe lang een lijst of array is, kun je twee dingen doen: je maakt het laatste element (of de pointer die daar naar wijst) 0, of je zet de lengte in het eerste element. Beide manieren hebben zo hun voor- en nadelen. En je kunt in een gelinkte lijst ook een pointer opnemen naar het vorige element, dan kun je er in twee richtingen doorheen.
Nou werden programma's nogal groot en onoverzichtelijk en hebben we daar nog een nieuw type opslag aan toegevoegd: objecten. Daarbij worden zowel de gegevens als de programmacode gecombineerd. We noemen zo'n datatype tegenwoordig een class. Dat ziet er als volgt uit:
code:
1
2
3
4
5
6
7
8
9
10
| Class Artikel ------------- Serienummer (1 woord) Aantal (1 woord) Prijs (2 woorden) String met Naam (max. 255 tekens) Functie IsOpVoorraad: return Aantal > 0; Functie WijzigNaam(string NieuweNaam): Naam = NieuweNaam; Functie AantalVerkocht(cardinal Verkocht): Aantal = Aantal - Verkocht; Functie NieuweVoorraad(cardinal Binnengekomen): Aantal = Aantal + Binnengekomen; |
Die functies (en de definities daarvan) noemen we methodes en je hoeft ze natuurlijk slechts eenmalig op te slaan. En je kunt een class uitbreiden door er nieuwe variabelen of functies achteraan te plakken.
Je gebruikt een methode door hem als eerste parameter een pointer naar het datablok te geven, zoals:
code:
1
| (*(*Artikel) + Wijzignaam)(11634, "Badhanddoek") |
(Dat betekent: de inhoud van (de inhoud van de pointer naar Artikel + de offset naar de methode) aanroepen als functie met de parameters 11634 en "Badhanddoek".)
Om het wat leesbaarder te maken:
code:
1
2
3
| Artikel.WijzigNaam(11634, "Badhanddoek") of Artikel->Wijzignaam(11634, "Badhanddoek") |
Of om het nog mooier te maken:
code:
1
| Artikel[11634].WijzigNaam("Badhanddoek") |
Het nummer (11634) is dan de pointer naar het record met daarin de object data. En alle bovenstaande voorbeelden betekenen hetzelfde, het hangt van de programmeertaal af welke je moet gebruiken. En er zijn meer mogelijkheden.
1 van de mooie dingen van zulke objecten is dus dat je er dingen aan toe kunt voegen en zo nieuwe objecten kunt maken. Je kunt (meestal) ook dingen verwijderen of overschrijven.
We hebben in de bovenstaande class bijvoorbeeld de functie AantalVerkocht, die de opgegeven hoeveelheid aftrekt van Aantal. Maar nu willen we een nieuwe class maken met een nieuwe functie die controleert of het totaal dan niet negatief is:
code:
1
2
3
4
| Class BetereArtikelen --------------------- Pointer naar Class Artikel Functie AantalVerkocht(cardinal Verkocht): if Verkocht <= Aantal then Aantal = Aantal - Verkocht; |
Dat is natuurlijk wel verwarrend, want je hebt nu twee keer een methode met dezelfde naam. Als het mogelijk moet zijn om bestaande methodes te kunnen wijzigen, kun je er beter pointers van maken:
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| Class Artikel ------------- Serienummer (1 woord) Aantal (1 woord) Prijs (2 woorden) String met Naam (max. 255 tekens) Pointer naar functie IsOpVoorraad Pointer naar functie WijzigNaam(string NieuweNaam) Pointer naar functie AantalVerkocht(cardinal Verkocht) Pointer naar functie NieuweVoorraad(cardinal Binnengekomen) Class BetereArtikelen --------------------- Pointer naar Class Artikel Pointer naar functie AantalVerkocht(cardinal Verkocht) |
Je kunt dan ook de functie AantalVerkocht in de class Artikel vervangen door de nieuwe versie, of voor de nieuwe class een kopietje maken en het daar vervangen:
code:
1
2
3
4
5
6
7
8
9
10
| Class BetereArtikelen --------------------- Serienummer (1 woord) Aantal (1 woord) Prijs (2 woorden) String met Naam (max. 255 tekens) Pointer naar functie IsOpVoorraad Pointer naar functie WijzigNaam(string NieuweNaam) Pointer naar functie AantalVerkocht(cardinal Verkocht) <-- dit is de nieuwe Pointer naar functie NieuweVoorraad(cardinal Binnengekomen) |
Het hangt af van de programmeertaal hoe dat precies werkt en wat je mogelijkheden zijn. En als je het anders wilt, kun je het natuurlijk ook zelf maken.
En die kunnen we dus als laatste toevoegen aan onze lijst:
20. Arrays (variabele lengte)
21. Records (variabele lengte)
22. Gelinkte lijsten (variabele lengte)
23. Objecten of Classes (variabele lengte)
En natuurlijk kun je al deze dingen weer verder combineren.
:strip_icc():strip_exif()/u/43400/avatar.jpeg?f=community){kind=avatar}
Misschien beter iets voor een (of je) blog? Een wiki ergens?
Dit topic is gesloten.