Dit document werd het laatst aangepast op 10 februari 2004
«VOORSTGE.HTM»

• het binair systeem is slechts één van de mogelijke digitale (discrete) systemen;
   
  
• in het binair systeem kan één digit slechts twee mogelijke waarden hebben (vandaar de naam BIT, wat een samentrekking is van BInary digiT). 
  

De meerwaarde van het binaire systeem zit vooral in de combinatie van twee factoren:

• de technische eenvoud van het systeem, waardoor het productietechnisch gemakkelijker en goedkoper was om snelle binaire rekeneenheden en binaire geheugens te maken;
   
  
• de superinteressante mogelijkheid om op een éénvoudige manier, van een "vervuild" binair signaal, weer het oorspronkelijke foutvrije signaal te recreëren.

Dit tweede punt is echt niet te onderschatten. Het is een technische handigheid waarmee men overal waar binaire signalen doorgegeven moeten worden zich kan ontdoen van allerlei stoorsignalen. Dit "opzuiveren" van binaire signalen kan zowel binnenin de computer tussen verschillende onderdelen, als tussen verschillende computers of communicatie-apparatuur toegepast worden. Hierdoor is het mogelijk dat een binair signaal uit Guatemala via 37 tussenstations toch nog foutvrij in Bommerskonten kan aankomen.

Het is een basisgegeven in de elektronica dat elk signaal dat bewerkt, doorgestuurd versterkt of verzwakt wordt, steeds een beetje "vervuild" wordt door allerlei storende invloeden. Deze "ruis" uit zich meestal als meerdere afwijkingen t.o.v. het oorspronkelijke signaal. Het is nu de kunst om op basis van het vervuilde signaal zo goed mogelijk het oorspronkelijke signaal weer te voorschijn te toveren.
Het principe hierbij is vrij simpel. Het ontvangen signaal wordt gemeten en zolang dit signaal beneden de criteriumwaarde "C0" blijft wordt er van uitgegaan dat het oorspronkelijke signaal wel een "0" zal voorgesteld hebben. Dan wordt voor het verder doorsturen van dit signaal opnieuw een perfecte "0"-waarde gegenereerd.

Wanneer het ontvangende signaal echter boven de criteriumwaarde "C1" uitkomt gaat men ervan uit dat het oorspronkelijke signaal dan wel "1" zal geweest zijn, en wordt er dus voor het verder doorsturen van dit signaal een perfecte "1"-waarde gegenereerd.

In het bijzondere geval waarbij het ontvangen signaal ergens te lang blijft haperen tussen criteriumwaarde "CO" en "C1" (een silly bit) kan het systeem niet kiezen en besluit het tot een foutmelding (vb. kan de diskette niet lezen), of stopzetting van de datatransfer of een interne vraag om de boodschap nog eens opnieuw door te sturen.
 
Opdracht: geef een drietal voorbeelden van echt digitale systemen (er hoeft geen foutcorrectie aan te pas te komen):
 

1)
 

2)
 

3)
 
 

Meer informatie over de omzetting van allerlei analoge naar binaire signalen, en meer over de algemene kenmerken van gegevensopslag vind je in het hoofdstuk over de "Algemene kenmerken van gegevensopslag".
 

 
Voor alle gegevens die we door de computer willen laten bewerken zullen we een "interne voorstelling" van die gegevens moeten vastleggen. Op die manier kunnen we gegevens aan de computer doorspelen (input), kan de computer die gegevens bewerken en bijvoorbeeld tijdelijk opslaan, en de bewerkte of gestockeerde gegevens ooit eens terug naar de buitenwereld brengen (output).

Alle dergelijke gegevens kunnen in drie grote categorieën ondergebracht worden:

• Booleaanse waarden,
• getallen,
• alfanumerieke tekens en controle- of besturingstekens.

Hieronder behandelen we elk van deze gegevenssoorten.

 
Van sommige kenmerken volstaat het dat wij (of programma's) weten of dat kenmerk "aan" of "uit" staat. Deze "binaire" vormen van informatie worden ook "logische vlaggen" genoemd. Je hangt de vlag uit als de eigenschap (weer) aanwezig is, je haalt de vlag binnen als de eigenschap niet (meer) aanwezig is. De computer kan op gelijk welk moment de status van die vlag uitlezen en er rekening mee houden.

Voorbeelden: moet een woord in het vet weergegeven worden of niet? Zit er een diskette in het diskettestation of niet? Wil de gebruiker de afdrukopdracht doorvoeren of cancelen? Is de inhoud van variabele A gelijk aan de inhoud van variabele B of niet? Moet die ene harde schijf in de pc nu als Master- of als Slave-apparaat benaderd worden?

Zo zijn er duizenden elementaire brokjes informatie, dus duizenden logische vlaggen, die door pc's onthouden, gezet, uitgelezen of gewijzigd moeten worden.

Uit erkentelijkheid voor George Boole, een negentiende eeuwse Engelse wiskundige, die de regels van de bewerkingen met deze waarden voor het eerst opstelde, worden deze binaire waarden ook wel Booleaanse waarden of Booleans genoemd.
De regels die de bewerkingen met Booleaanse waarden beschrijven noemt trouwens ook de "Booleaanse algebra".

Dergelijke Booleaanse waarden of logische vlaggen kunnen op verschillende manieren aan programma's doorgegeven worden:

• zo zal een hardwarematige sensor "voelen" of er een diskette in het diskettestation zit en dit via een elektronisch signaaltje doorgeven aan het beturingssysteem van de pc;
   
• via een klein elektrisch geleidend nokje, dat een perfect contact kan maken tussen twee aansluitpinnen, wordt op fysieke wijze een harde schijf ingesteld als master of slave. Dergelijke "nokjes" noemt men ook "Jumpers". In feite fungeert de aan- of afwezigheid van een jumper over twee contactpunten als een binaire schakelaar: of er is contact of er is geen contact. De toestand van dit contact kan perfect uitgelezen worden door de pc en doorgegeven worden aan het besturingssysteem;
   
• of de gebruiker een printopdracht wil laten doorgaan of wil cancelen wordt afgeleid op welke van de beide knoppen de gebruiker klikt. Klikt de gebruiker op de knop "OK" dan kan voor de eigenschap "doorgaan" de waarde "1" aan het printprogramma doorgegeven worden. Klikt de gebruiker daarentegen op de knop "Cancel" dan kan voor de eigenschap "doorgaan" de waarde "0" aan het printprogramma doorgegeven worden. Op basis van die 1 of 0 moet het printprogramma dan maar het overeenkomstige vervolg voorzien;
   
• in een programma mag je nooit delen door "0". Laat je dit toch doen dan kan de pc vastlopen. Een degelijk geschreven programma moet in principe dan ook steeds een deling door 0 beletten. Dit kan door, vooraleer de deling uit te voeren, de waarde van de deler te vergelijken met "0". In het programma komt dan ergens een "IF THEN ELSE"-clausule waar, tijdens de IF-fase, de deler vergeleken wordt met 0. Het resultaat van die vergelijking kan slechts twee waarden aannemen: of de deler is gelijk aan nul, of hij is niet gelijk aan nul. Op basis van dat binair resultaat laat je de deling ofwel doorgaan, of je laat het programma een foutboodschap genereren waarin netjes verwezen wordt naar het opgedoken probleem en je laat het programma deftig afsluiten (in plaats van het in de prak te laten lopen). In feite merken we hier dus dat een programma, geheel zelfstandig, op basis van vergelijkingsopdrachten, logische vlaggen kan aan- of afzetten.
   

 
Behalve de logische vlaggen die via een "jumper" of een andere "sensor" gezet worden, worden de andere logische vlaggen vanuit programma's of op basis van instellingen die in het BIOS of ergens op een harde schijf opgeslaan zijn, naar het werkgeheugen gekopieerd.
 
Eén logische vlag komt perfect overeen met de kleinste eenheid van geheugenopslag, met name de BIT.

Ondertussen zijn computergeheugens dermate geëvolueerd dat gegevens niet meer per individuele bit opgeslaan worden, maar per byte (of zelfs reeksen van 2, 4 of 8 bytes).

Behalve in enkele zeer uitzonderlijke gevallen is het zo dat 1 byte de inhoud van 8 bits voorstelt. Per byte kunnen we dus de inhoud van 8 verschillende logische vlaggen bijhouden. Heb je nood aan 9 logische vlaggen, dan heb je minstens 2 bytes nodig, maar met die 2 bytes kan je in totaal wel 16 logische vlaggen bijhouden, enz.

Als je een programma schrijft hoef je je niet bezig te houden met de vraag "waar heb ik die logische vlag alweer verstopt?". In elke programmertaal kan je een "Logische vlag" of "Flag" of "Boolean" gewoonweg declareren (= een naam, een type en soms een lengte geven) en de compiler zal zich verder wel bekommeren over de plaats waar uw binaire variable opgeslaan wordt.

In (Turbo) Pascal geef je bijvoorbeeld via:

  var
     A,B: boolean;
 
  begin
   A := True;
   B := False;
   enz...

aan dat je in je programma twee variabelen, genaamd "A" en "B" wenst te gebruiken, die alleen de waarden "True" of "False" kunnen aannemen. Als eerste instructie in je programma, zet je de waarde van A op True; m.a.w. je initialiseerde de logische vlag als "Aan".

Het is de compiler van dit programma die zal uitmaken of de logische vlaggen A en B al dan niet in dezelfde geheugenbyte zullen bijgehouden worden. Dit aspect is dus voor een Pascal-programmeur transparant en niet onder zijn controle. In de praktijk maakt dit ook niet veel uit.

In databanken heb je meestal ook een Booleaans gegevenstype dat u toelaat met een minimum aan geheugenruimte toch tal van binaire waarden op te slaan. Zo heb je in Access de mogelijkheid om voor een veld het gegevenstype "Ja/Nee" te selecteren (en bij de helptekst vind je heel netjes dat de lengte van dit gegevenstype gelijk is aan 1 bit).

 
Met 1 bit kan je maximaal twee waarden voorstelen, bv. 0 en 1. Daar zal je dus niet ver mee springen als je grotere getallen wenst weer te geven. Toch willen we gebruik blijven maken van het voordeel van de binaire opslagtechniek. Dan zit er niet veel anders op dan te pogen om grotere getallen dan 0 en 1 voor te stellen door reeksen van meerdere bits. Een opeenvolgende reeks van bits of bytes die samen iets voorstellen, noemt men ook wel eens een "string"; vandaar het begrip "stringvorming".

Afhankelijk van het totaal aantal bits dat we als groep beschouwen zullen we dus meer of minder verschillende waarden, getallen, kunnen voorstellen.

Hoeveel precies kunnen we beginnen afleiden uit onderstaande tabellen.

 
Per extra bit die we gebruiken, verdubbelen we het totaal aantal mogelijk voor te stellen waarden. Dit is logisch omdat elke bit 2 waarden kan aannemen. Net zoals we bij het decimaal talstelsel het aantal mogelijke waarden vertienvoudigen als we een extra cijfer gebruiken (omdat per cijferpositie, of per rang, in het tiendelig talstelsel we 10 verschillende waarden kunnen noteren).

Algemeen kunnen we zeggen dat voor gelijk welk talstelsel, per extra rang die we gebruiken om onze getallen voor te stellen, het totaal aantal voor te stellen mogelijkheden vermenigvuldigd wordt met het aantal mogelijke verschillende waarden die op één positie kunnen voorkomen.

Dat aantal mogelijke verschillende waarden per positie noemen we het grondtal van het talstelsel.

Voor het binaire talstelsel hebben we slechts 2 mogelijke waarden per positie (0 en 1), vandaar dat het grondtal bij het binair talstels 2 is.

In het "octale" talstelsel hebben we acht verschillende symbolen die we op één positie kunnen gebruiken (0, 1, 2, ...7), vandaar dat het grondtal hier 8 is.

In het "decimale" stelsel, dat we allemaal heel goed kennen, hebben we tien verschillende symbolen per rang. Daaruit volgt dat het decimaal talstelsel het grondtal 10 heeft.

Op die manier kan je zelf allerlei talstelsels uitdenken. Er is er echter nog eentje dat ons in de informatica erg interesseert en dat is met name het "hexadecimale" talstelsel. In dit talstelsel gebruiken we tot zestien verschillende tekens op één rang (0, 1, 2, ....9, A, B, C, D, E en F) «in sommige boeken gebruikt men kleine letters voor de waarden A...F, maar er wordt wel dezelfde getalwaarde mee bedoeld». Het grondtal van het hexadecimale talstelsel is dus uiteraard 16. We komen verder nog terug op een handig voordeel van het hexadecimale talstelsel.

Nu even terug naar het binaire systeem.

In feite komt het totaal aantal verschillende waarden die we met een bitstring kunnen voorstellen perfect overeen met wat het binaire talstelsel ons leert, nl:
het maximum aantal verschillende waarden die we kunnen voorstellen door een rij van n bits is gelijk aan het binaire grondtal 2 tot de n^de macht.

In de onderstaande tabel geven we als referentie nog eens de mogelijkheden voor veel gebruikte bitstring-lengtes. Het zal u niet verbazen dat je de maximumwaarden die daarmee voorgesteld worden heel vaak tegenkomt in de informatica. Denk maar aan aantal kleuren die beeldschermen kunnen weergeven, aantal grijswaarden die een scanner kan reproduceren, grootste natuurlijk getal dat door een bepaald type variabele kan voorgesteld worden, hoeveelheden geïnstalleerd geheugen, etc.

Afhankelijk van de grootte-orde van de getallen waarmee we onze computer willen laten rekenen, zullen we dus op één of andere manier een keuze moeten maken over "het aantal bits op rij" dat we zullen gebruiken om die getallen mee voor te stellen. De computer moet ten slotte bij voorbaat weten hoeveel bits of bytes aan geheugenruimte die zal moeten gebruiken om de waarden in op te slaan. We hebben daar geen onbeperkte keuze in. Deze keuze wordt beperkt door het type processor van de computer, het geheugensysteem en vooral door de gebruikte achterliggende programmeertalen.

In programmeertalen doet men dat via de (expliciete of impliciete) declaratie van het gegevenstype voor de getallen.

Voorbeeldje: in Turbo Pascal kan je aangeven dat je wenst te werken met een variabele die alleen positieve getallen zal moeten bevatten die kunnen variëren van 0 tot 255 (geen kommagetallen toegelaten, handig voor kleine tellertjes). Een ander datatype laat positieve getallen tot 65 535 toe (ook hier geen kommagetallen). Op die manier kan je via:

aangeven dat je twee variabelen wenst te gebruiken die elk alleen maar positieve (natuurlijke) getallen zullen bevatten (0 inclusief) waarbij de maximumwaarde die je voor "Tellerke1" voorziet gelijk is aan 255, en de max.waarde voor "KleinTotaal" gelijk is aan 65 535.

Als je programma hier poogt een grotere waarde in te stoppen dan krijg je een "Overflow" of gelijkwaardige fout.

Je merkt dat deze twee type-declaraties perfect overeen komen met een bitlengte van 8 en 16 (ofte 1 en 2 bytes). Je kan bij Turbo Pascal ook niet zomaar kiezen voor bv. een bitlengte van 13.

De meeste gegevenstypes voor getallen komen steeds overeen met een veelvoud van een byte (1, 2, 4 en uitzonderlijk 6 of 8 bytes), omdat dit gemakkelijk adresseerbare gehelen zijn voor de moderne computers.

Allerlei toepassingsprogramma's hebben hun eigen interne datatypes, waarbij de gebruiker niet meteen zicht heeft op hoe die getallen inwendig in de computer voorgesteld zullen worden (voorbeeld Excel, Javascript). Vooral in toepassingsprogramma's of programma's die geschreven zijn in programmeertalen waarbij het declareren van variabelen niet meer expliciet hoeft, is het vaak onduidelijk hoe bepaalde variabelen dan echt inwendig voorgesteld worden.

Misschien herinner je nog de begrippen als natuurlijke, gehele, reële en complexe getallen uit de lessen wiskunde. Misschien doet "de wetenschappelijke getalnotatie" ook nog een belletje rinkelen.

Waar het om gaat is dat we alle getallen die we misschien wel eens met een computer zouden willen bewerken, kunnen indelen op basis van verschillende criteria, zoals bijvoorbeeld:

• de maximumgrootte,
• alleen positieve getallen of moeten er ook negatieve getallen voorgesteld kunnen worden,
• zijn het kommagetallen,
• de gevraagde preciesheid.

Hoe groter de eisen die aan de voorstelling van een getal gesteld worden, hoe complexer de inwendige voorstelling ervan en vooral hoe meer tijd de bewerkingen met dat getalstype vragen. Zo zijn de processoren verschrikkelijk snel in het optellen van twee variabelen die als natuurlijke getallen gedeclareerd zijn, terwijl het optellen van twee zeer grote negatieve kommagetallen met maximale preciesie snel enkele extra processorcycli in beslag neemt.

Vaak gebruikte getaltypes in computers zijn:

• de natuurlijke getallen (uitsluitend positieve gehele getallen zonder decimale fracties),
• de gehele getallen (positieve en negatieve zonder decimale fracties, de integers),
• de reële getallen (positieve en negatieve met cijfers na de komma, de reals),
• de complexe getallen.

In het kader van deze cursus gaan we ons alleen echt verdiepen in de inwendige voorstelling van de twee eerst vermelde types (alhoewel de inwendige voorstelling van de reële getallen met verschillende gradaties van preciesie ook bijzonder leerrijk kunnen zijn voor de wiskundige en wetenschappelijke richtingen; deze worden dan ook slechts kort besproken).

De inwendige voorstelling van de natuurlijke getallen in computers gebeurt op de meest efficiënte wijze als een rechttoe rechtaan toepassing van het binair talstelsel zoals hoger reeds beschreven. Daarom gaan we hier nog wat uitweiden over het binair talstelsel, enkele binaire bewerkingen, omzettingen van binair naar decimaal en omgekeerd.

Computerprocessoren zijn bijzonder handig, volkomen precies en zeer snel in het werken met dit type getallen. Het enige wat bij voorbaat duidelijk moet afgesproken worden is de lengte van de bitstring die je zal gebruiken om een bepaalde variabele voor te stellen (gebeurt in de declaratiefase).

Voor zij die het nog niet wisten - de basisregels voor het optellen van binaire getallen:

In het laatste geval hebben we te maken met een "overdracht" naar een volgende, meer significatieve rang. Dit klinkt wat ingewikkeld maar het wil gewoon zeggen dat binnen de positie (de rang) waar we aan het optellen waren, alle mogelijke symbolen uitgeput hebben en we dus moeten overgaan naar een volgende rang (een meer significante rang). De rang waar elk cijfer x keer meer voorstelt dan hetzelfde cijfer in de vorige rang. "x" is daarbij gelijk aan het grondtal van het talstelsel. In dit geval is de 1 in 10 tweemaal zoveel waard als de 1 in 01. Net hetzelfde wanneer je in het decimale stelsel 4 en 6 optelt en dus noodgedwongen naar 10 moet overgaan. Daar is de 1 in 10, tienmaal zoveel waard als de 1 in 01.

In de volgende afbeelding wordt het principe van "overdracht" bij de decimale optelling visueel vorgesteld.

 
In de onderstaande afbeelding wordt het principe van "overdracht" bij de binaire optelling visueel vorgesteld.

 
De optelling van twee natuurlijke binaire getallen (inclusief overdracht etc.) is voor een computerprocessor kinderspel en elektronisch erg eenvoudig. Toch is er een mogelijke foutenbron. Neem bijvoorbeeld onderstaande optelling van twee variabelen met bitlengte 8 waarvan je het resultaat wenst over te brengen naar een variabele van eveneens 8 bits lang.

 
In bovenstaand geval is het resultaat van de optelling in feite te groot om nog in een bitstring van 8 bits voorgesteld te kunnen worden. Gevolg: de bewerking kan niet correct beëindigd worden.

 
Om in het vervolg aan te geven of we nu met een binair, octaal, decimaal of hexadecimaal getal werken zullen we er tussen haakjes en in subscript het grondtal bij plaatsen.
 
Zo is 1111₍₂₎ = 17₍₈₎ = 15₍₁₀₎ = F₍₁₆₎.
 

Opdracht: ga na in Turbo Pascal wat er gebeurt als je de som laat maken van twee getallen en het resultaat wenst toe te wijzen aan een datatype dat te klein is voor het resultaat. Hoe reageert het programma? Kan je dit voorkomen?
 
 
 

Er zijn verschillende methodes om de decimale waarde van een binair voorgesteld getal te bekomen.

Een zeer eenvoudige methode: gebruik een wetenschappelijk rekenmachine of gebruik de rekenmachine die standaard terug te vinden is onder de programma's van de Bureau-accessoires die met de Windows' besturingssystemen worden meegeleverd (wel eerst even kiezen voor "Beeld", "Wetenschappelijk"). Je moet natuurlijk een dergelijk toestel of software bij de hand hebben.

Via de tabellen zoals je die hierboven in deze tekst kan aantreffen kan je uiteraard ook van het ene talstelsel naar het andere overwippen. Meestal zijn de tabellen echter niet groot genoeg.

De waarde bit per bit, volgens de waarde van de bitrang, omzetten naar de decimale waarde en alle bekomen waarden optellen.

Voorbeeld: het binaire getal 10111001₍₂₎

De rangwaarden voor het binair stelsel zijn =   2 ^{rangnummer (te beginnen bij 0 vanaf rechts)}

rangwaarden in formulevorm    27   26    25   24   23   22    21   20    
rangwaarden in dec. getal = 128   64   32   16    8    4    2    1
symbool op die rang       x   1    0    1    1    1    0    0    1
voorgestelde dec. waarde  = 128 +  0 + 32 + 16 +  8 +  0 +  0 +  1 = 185(10) 

Voor de wetenschappelijker richtingen kan je dit ook algebraïsch als volgt voorstellen:

 
en in iets leesbaarder Nederlands wil dat dan zeggen dat:

voor elk natuurlijk getal g geldt dat,
als de binaire voorstelling ervan een reeksje van n + 1 bits is, gaande van alfa _n tot alfa ₀
en waarbij alfa (het symbool van de bits) alleen maar een 0 of een 1 kan zijn,
en waarbij i gaat van 0 tot n (in volledige eenheden),
dan is de decimale waarde van het getal g = de som van alle producten van elke bitwaarde vermenigvuldigd met zijn overeenkomstige rangwaarde (2^{tot de macht van n tot 0}).

Het is hierbij interessant om op te merken dat, als we een getal voorstellen door 8 bits, n slechts als hoogste waarde 7 krijgt (omdat de macht van de minst significante bit 0 is).

Eveneens is het belangrijk vast te stellen dat het grootste getal dat we op die manier kunnen voorstellen met een binair getal van 8 bits lang, 255 is en niet 256, wat nochtans het totaal aantal verschillende waarden is die we kunnen voorstellen met 8 bits! Dit komt omdat we ook de waarde 0 moeten kunnen voorstellen: dus maximum aantal verschillende waarden bij 8 bits is 256, de grootst mogelijke waarde van de natuurlijke getallen is 255 als we ook 0 willen kunnen voorstellen.

Vermenigvuldigen van de meest significante bit met 2, optellen bij de volgende rang, terug maal 2 enz. tot wanneer je zo de waarde van de minst significante rang mee opgeteld hebt.

In de volgende afbeelding wordt deze methode visueel veel duidelijker.

De waarde van de meest linkse bit vermenigvuldigen met 2, dit product optellen bij de volgende rang, deze som terug vermenigvuldigen met 2, dit product terug optellen bij de volgende rang, enz. tot en met de som met de laatste rang.

Dit is een zeer handige methode die je gemakkelijk, snel en zonder enige rekenmachine kan uitvoeren. Je hoeft niet eens alle machten van 2 te kennen.
 

Er zijn ook verschillende methodes om de binaire waarde van een decimaal voorgesteld getal te bekomen, waaronder ook hier natuurlijk de twee simpelste: gebruik een wetenschappelijke rekenmachine (of gebruik de rekenmachine die standaard terug te vinden is onder de programma's van de Bureau-accessoires die met de Windows' besturingssystemen worden meegeleverd (wel eerst even kiezen voor "Beeld", "Wetenschappelijk")) of je gebruikt een tabel met in de ene kolom de decimale voorstelling en in de andere kolen de overeenkomstige binaire voorstelling.

Ook hier hebben we echter een methode waarbij je geen tabellen of rekenmachines nodig hebt.

Delen door 2, restwaarde noteren, herhalen tot wanneer het resultaat van de deling 0 wordt.

Om handig te werken plaats je het decimale getal helemaal rechts van je blad (omdat dan de bits meteen in de juiste volgorde staan).

In de volgende afbeelding wordt deze methode visueel veel duidelijker.

De gehele getallen bevatten naast de natuurlijke getallen ook de negatieve getallen (weliswaar nog steeds zonder fracties achter de komma).

We moeten dus op één of andere wijze aangeven dat het getal positief of negatief zal zijn. Daar dit slechts een gewone tweeledige keuze is, ligt het voor de hand dat we daar dus 1 bit uit de bitstring zullen voor gebruiken. Hiervoor zouden we bijvoorbeeld de meest linkse bit kunnen gebruiken en afspreken dat indien deze bit "af staat" (dus = 0) we te doen hebben met een positief getal, in het andere geval betreft het een negatief getal.

Voor de positieve getallen kunnen we dus blijven verder werken als bij de natuurlijke getallen, alleen mogen we de eerste bit niet meer gebruiken om de "waarde" van het getal te berekenen. Dit houdt uiteraard ook in dat het maximum aantal verschillende (positieve) waarden die we kunnen voorstellen met een bitstring van n bits voor gehele getallen, slechts de helft is van het aantal verschillende (uiteraard positieve) waarden die we kunnen voorstellen met dezelfde bitstring voor natuurlijke getallen.

Maar dan nog hebben we verschillende mogelijkheden om die negatieve waarden voor te stellen. In onderstaande tabel worden een aantal mogelijkheden naast elkaar gezet en als referentie geven we eerst nog even de voorstelling van de natuurlijke getallen erbij; voor de overzichtelijkheid hebben we hier gewerkt met een bitstring van slechts 4 bits lang.
 

Bij het systeem dat heet: de "tekengrootte representatie" gaan we de positieve getallen gewoon voorstellen zoals we dat reeds kennen van bij de natuurlijke getallen (met uitzondering van de tekenbit natuurlijk). Voor de negatieve getallen neemt men gewoon het systeem van de natuurlijke getallen over, alleen stellen de berekende waarden nu een negatief getal voor (omdat de meest linkse bit op 1 staat).

We kunnen dus dezelfde vormen van omzetting gebruiken alleen moeten we weten dat het "-"teken verscholen zit in de meest linkse bit.

Voor de wetenschappelijker richtingen kan je dit ook algebraïsch als volgt voorstellen:

 
De voor- en nadelen van deze methode bespreken we verder.

Bij het "One-s complement" gaat men voor de positieve getallen ook hetzelfde systeem gebruiken als bij de tekengrootte voorstelling, maar hier gaat men een negatief getal voorstellen als het complement van het positieve getal. Met andere woorden, waar er bij het positieve getal een 0 staat op een bitrang, komt er een 1 op die bitrang voor het negatieve getal. Evenzo waar er bij het positieve getal oorspronkelijk een 1 staat, komt er een 0 in het negatieve getal. Dit noemt men ook het inverteren van de bits.

Voorbeeld: de decimale getallen +1 en -1 en +6 en -6 worden in het One's complement (met bitlengte 4) als volgt voorgesteld:

Op zich is dit geen betere of slechtere manier van voorstellen dan de tekengrootte representatie. Een computerprocessor kan even gemakkelijk een tekenbit plaatsen (bij de tekengrootte representatie) of alle bits inverteren (bij de one's complement representatie).

Voor het echte rekenwerk blijkt het technisch echter gemakkelijker te zijn om een elektronische schakeling te bouwen die met complementgetallen kan werken i.p.v. tekengrootte representatie.

Beide systemen hebben echter wel één zeer groot nadeel: voor de "0"waarde zijn er twee representaties mogelijk. Via deze systemen introduceert men in feite ook een "negatieve" 0 waarde.

Afgezien van het feit dat dit wiskundig discutabel is, wordt het er ook voor een processor niet eenvoudiger op wanneer men bv. de waarde van twee variabelen wenst te vergelijken. In A zit bv. de positieve 0-waarde en in B de negatieve 0-waarde.
Bij een vergelijkingsoperatie is het elektronisch veel simpeler dat de processor gewoon de verschillende bits van variabele A, bit per bit kan vergelijken met de bits van B.
Noch bij de tekengrootte voorstelling, noch bij de one's-complement voorstelling zou een dergelijke vergelijking van A en B ons duidelijk maken dat die getallen in feite wel gelijk zijn.

Deze dubbelzinnigheid heeft men in het volgende systeem proberen te verhelpen, en wonder boven wonder, men heeft er nog enkele toemaatjes bijgekregen ook (waarover verder meer).

Voor de liefhebbers van formules geven we hieronder ook nog eens de algebraïsche voorstelling van het one's-complement systeem:

Ook hier gaat men de positieve getallen op dezelfde wijze blijven voorstellen als bij de natuurlijke getallen (met uitzondering van de tekenbit natuurlijk).

Voor de negatieve getallen echter vertrekt men van het systeem van het one's complement maar men omzeilt de negatieve 0 door de waarde van alle negatieve getallen nog eens met 1 te verminderen.
Dus de negatieve 0 uit het one's complement wordt in het two's complement -1, en op die manier kunnen we aan de negatieve kant zelfs steeds 1 eenheid meer voorstellen dan aan de positieve kant (voorbeelden: bij een bitlengte van 4 is het grootste positieve getal 7, terwijl het "grootste" negatieve getal (in feite het kleinste) -8 is; bij een bitlengte van 8 worden dat respectievelijk 127 en -128).
 

Omzetten van decimaal naar two's complement met een bitlengte = n

Als voorbeeld gaan we hier de decimale getallen 7 en -7 eens omzetten in de two-complementsrepresentatie met een bitlengte van 4.

A)      Positieve getallen

Zet het decimaal getal om naar een binair getal volgens de methodes die we zagen bij de natuurlijke getallen.

0 <- 1 <- 3 <- 7
1    1    1

Heb je méér dan n - 1 bitrangen nodig om dit getal binair voor te stellen, dan is dit getal te groot om (zowel in de tekengrootte als de one's complement als in) het two's complement systeem te worden voorgesteld.

Kan je het getal wel voorstellen met n - 1 bitrangen, dan voeg je helemaal links de tekenbit 0 toe en klaar is Kees.

0111
 
 
B)      Negatieve getallen

B.1)   Zet eerst het negatieve decimaal getal om naar zijn absolute waarde.

-7  =>  7

B.2)   Trek hier 1 decimaal af.

7 - 1 =  6
 
B.3)   Zet het bekomen getal om (dus zonder rekening te houden met het teken) naar de volledige two's complement voorstelling zoals bij de positieve getallen (zie hierboven - inclusief reeds het toevoegen van de tekenbit = 0).

0 <- 1 <- 3 <- 6
1    1    0
0110
 
B.4)   Inverteer alle bits (inclusief de tekenbit die we in de vorige stap op 0 gezet hadden).
 
0110
=>
1001
 
 
Opdracht:

zet onderstaande getallen om naar de two's complement representatie met een bitlengte van 8.

0₍₁₀₎

-1₍₁₀₎

40₍₁₀₎

-40₍₁₀₎

128₍₁₀₎

-128₍₁₀₎

Voor de liefhebbers van formules geven we hieronder ook nog eens de algebraïsche voorstelling van het two's-complement systeem:

Voordelen van de two's complement representatie

Deze voorstellingswijze heeft enkele voordelen t.o.v. de tekengrootte representatie en de one's complement representatie:

• het totaal aantal verschillende waarden die we hier mee kunnen voorstellen is ééntje groter dan bij de andere twee systemen;
   
• het getal 0 wordt slechts één keer voorgesteld, waardoor er geen problemen meer ontstaan met het vergelijken van de twee mogelijks verschillende voorstellingen van de 0 waarden in de andere systemen;
   
• voor een computerprocessor is het met de two's complement representatie elektronisch veel eenvoudiger om negatieve en positieve getallen op te tellen.
   
  Zo kan je bv. gemakkelijk A = 3₍₁₀₎ en B = -2₍₁₀₎ in het two's complement systeem gewoon binair optellen
   
  A =  3₍₁₀₎ = 0011₍₂₎
  B = -2₍₁₀₎ = 1110₍₂₎
  C =  1₍₁₀₎ = 0001₍₂₎

Vooral deze twee laatste voordelen hebben er toe geleid dat in bijna alle computersystemen gehele getallen het efficiëntst en het vaakst worden voorgesteld door het two's complement systeem.

Hierbij gebruikt men steeds bij voorbaat vastgelegde bitlengtes (meestal veelvouden van 8).
Daar de huidige computerprocessoren intern vlot kunnen werken met bitlengtes van 32 bits, worden gehele getallen in computers ook vaak met een bitlengte van 32 voorgesteld.

In programmeertalen kan je weer via je declaraties aangeven of je met "Integers" (gehele getallen) wenst te werken, en hoe groot die wel moeten zijn.

Voorbeeldje: in Turbo Pascal kan je aangeven dat je wenst te werken met een variabele die zowel positieve als negatieve getallen zal moeten bevatten die kunnen variëren van -32 768 tot 32 767 (geen kommagetallen toegelaten).

Een ander datatype laat gehele getallen toe van -2 147 483 648 tot 2 147 483 647 (ook hier geen kommagetallen). Op die manier kan je via:

aangeven dat je twee variabelen wenst te gebruiken die elk gehele getallen zullen bevatten (0 inclusief) waarbij je verwacht dat er in de ene variabele veel grotere getallen zullen gestockeerd worden dan in de andere.
 

Opdracht: ga na wat de bytelengte is van beide datatypes:

 
integer

 
longint

Om reële getallen en/of enorm grote of enorm kleine getallen (breukgetallen, positieve en negatieve) voor te stellen in een computer moeten we nog andere systemen bedenken dan de voorgaande.

Voor zeer grote gehele getallen zou je steeds de bitlengte kunnen verhogen, maar dan ga je al snel voorbij de maximum bitlengte die een processor vlot in één bewerking kan behandelen (vb 32 bits). Het grote voordeel van dit systeem is dat je hoe dan ook een 100 % precisie houdt bij het werken met natuurlijke of gehele getallen.

Dan nog hebben we geen oplossing voor kommagetallen. Een eenvoudige truc hier is dat we inwendig voor de computer toch de voorstelling van een geheel getal behouden maar dat we er steeds aan denken dat die variabele bv. geen Euro's meer voorstelt maar (Euro-)centen. Met andere woorden, als de input voor een bepaalde variabele 22,33 EUR is, dan wordt deze in de betreffende variabele opgeslaan als 2 233. Dit maakt het voor de programmeur wel wat gecompliceerder want die moet er aan denken om bij het tonen of afprinten van de resultaten, het eindgetal steeds nog eens door 100 te delen. In feite werk je in zo'n systeem als het ware met "vaste kommagetallen" en behoud je ook de 100 % precisie van het werken met gehele getallen, alleen beperk je hier de maximumgrootte van het grootste getal met het aantal cijfers die je na de komma nodig hebt. Merk op dat de komma op zich dus niet echt opgeslaan wordt.

In veel statistische of wetenschappelijke toepassingen weet je echter niet bij voorbaat hoe extreem groot of klein de getallen waarmee je zal werken wel zijn. Vaak heb je er ook geen idee van hoeveel cijfers je na de komma nog wel nodig zal hebben. Om dit soort onzekerheden bij voorbaat op te vangen zijn er weer verschillende systemen mogelijk. We beperken ons hier tot de meest gebruikte methode.

In het systeem van de "drijvende kommanotatie" -ook wel floating point representation genoemd- wordt een getal voorgesteld door drie componenten:

• de coëfficiënt    C
   
• het basisgetal  B    en
   
• de exponent      e

het getal is dan =         C  x  B^e

bijvoorbeeld              7₍₁₀₎ =  7 x 10⁰

en                  0,000 7₍₁₀₎ =  7 x 10^-4

en             -7 000 000₍₁₀₎ = - 7 x 10⁶
 

Hierbij geldt dat binnen hetzelfde computersysteem en binnen hetzelfde type variabele (bijvoorbeeld Real in Turbo Pascal) er inwendig steeds dezelfde bitlengte gebruikt wordt voor  C  en  e  en men voor beide types steeds een geheel getal gebruikt (waarbij men voor  C  in feite een vaste komma representatie gebruikt (steeds slechts 1 cijfer voor de virtuele komma)).

Als je steeds hetzelfde grondtal gebruikt, dus B = constante, dan hoef je die niet steeds bij elk getal op te slaan en worden er in elk geval daardoor reeds x-aantal geheugenbits bespaard. Veel gebruikte waarden voor B zijn 2, 8, 10 en 16. Hoe groter de waarde van het grondtal, hoe extreem veel groter of kleiner het voorgestelde getal zal kunnen zijn. Daartegenover staat dat de precisie echter afneemt. Het is trouwens niet steeds mogelijk om een breukgetal perfect tot op de laatste fractie, exact voor te stellen. Denken we maar aan (ook voor het decimaal stelsel) oneindige reeksen zoals 1,33333... etc. Maar ook getallen die op het eerste zicht perfect zouden weergegeven kunnen worden, leveren soms al eens probleempjes op.

Voorbeeld: zo kan (afhankelijk van het gebruikte grondtal) 0,7₍₁₀₎ na omzetting naar een drijvende komma-getal en terug naar decimaal er uitzien als 0,699 999 999 999 999 999.
Dergelijke fenomenen heb je misschien al eens tijdens het werken met Excel ervaren.

Drijvende kommagetallen hebben in elk geval de voordelen dat je er zeer grote en zeer kleine kommagetallen kan mee weergeven.

De keerzijde van de medaille is dat:

• het voor een computerprocessor stukken ingewikkelder is om er mee te rekenen en dat deze berekeningen over meerdere processorcycli moeten uitgesmeerd worden (vandaar destijds de opkomst van een mathematische co-processor die precies voor rekenkundige bewerkingen met floating point getallen ontworpen werd);
   
• je een fractie aan precisie van de uiteindelijke berekeningen mee inlevert t.o.v. de bewerkingen met gehele en natuurlijke getallen (maar voor niet boekhoudkundige toepassingen is dit minimaal gebrek aan precisie meestal te verwaarlozen).

Om tegemoet te komen aan de verschillende noden van grootte-orde en preciesie biedt Turbo Pascal bv. maar liefst 4 types van drijvende komma getaltypes.
 
 
Opdracht:

Zoek deze vier types van drijvende komma getalvoorstellingen in Turbo Pascal en geef hun onderlinge verschillen.
 
 

1
 
 

2
 
 

3
 
 

4
 
 
 
 

Tot hiertoe hebben we het alleen maar over de voorstelling van logische vlaggen en getallen gehad. Nochtans bestaat een zeer groot deel van de taak van een computer uit het werken met alfa-numerieke tekens.

Het inbrengen, bewerken en weer te voorschijn brengen van zinnen (op scherm of op printers) is één van de meest voorkomende taken van pc's. Ook hier zal er dus een systeem moeten gekozen worden om terug op basis van het tweewaardig opslagsysteem te komen tot de interne voorstelling van alle letters, leestekens, cijferkarakters en een aantal "niet afdrukbare tekens" (ook wel eens controletekens of stuurcodes genoemd).

Het geheel van alfanumerieke tekens en stuurcodes die we moeten kunnen voorstellen omvatten o.a.:

• al de letters van ons normaal alfabet (zowel in hoofd- als kleine letters),
   
• de cijferkarakters 0 tot 9,
   
• de verschillende leestekens (inclusief de spatie die als apart teken beschouwd moet worden), bewerkingstekens, vaak voorkomende typografische tekens (, . ; : / = + ~ & ! < - > _ * % # @ de haakjes zelf, enz.),
   
• als stuurcodes heb je bv. de backspace, line feed, form feed, horizontale tab, carriage return, delete, end of transmission, end of medium, escape.
   

Opdracht: zoek de betekenis van
 
 
line feed
 
 

form feed
 
 

carriage return
 
 
 
 

Ook in het geval van het voorstellen van alfanumerieke tekens zullen we aan "stringvorming" moeten doen om alle noodzakelijke tekens te kunnen voorstellen. In tegenstelling tot de voorgaande categoriën kunnen we ons hier echter niet behelpen van wiskundige formules om de "waarde" of de "betekenis" van een bitstring af te leiden.

Bij gebrek aan een formule rest ons niets anders dan gebruik te maken van bij voorbaat vastgelegde afspraken waarbij voor elk alfanumeriek teken en elke stuurcode één bepaalde bitstring wordt gereserveerd. Een dergelijke overeenkomst is dan eigenlijk niets meer dan een tabel waarin aan de ene kant het voor te stellen teken staat, en aan de andere kant de overeenkomstige bitstring. In de Engelstalige literatuur spreekt men in dit verband vaak over "character encoding" of "code-mapping".

In principe zou elk computersysteem zijn eigen tabel kunnen gebruiken maar dan wordt elke communicatie met een ander systeem totaal onmogelijk. Om het mogelijk te maken dat tekstbestanden tussen verschillende computers onderling uitwisselbaar werden, of om er voor te zorgen dat de printer van fabrikant x toch ook bestanden van computerfabrikant y kon afprinten werden vanaf 1960 enkele "charactersets" algemeen aanvaard.

In de loop der jaren zijn er verschillende systemen ontwikkeld, waarvan er van de meeste systemen zelfs lokale varianten ontstaan zijn (zeg maar dialecten) om tegemoet te komen aan bijvoorbeeld de nood aan specifiek vaak gebruikte accenttekens (vb: é, è, à, á en â) of valutatekens ($, £ en ¥) of landspecifieke karakters (Å en ß) of bijzondere leestekens (¿).
 

Een eerste veel gebruikte tabel was een systeem met bitlengte 6 en was op zichzelf reeds een uitbreiding van de oorspronkelijke BCD-tabel met bitlengte 4. BCD was de afkorting van Binary Coded Decimals.

De uitbreiding van bitlengte 4 naar 6 zorgde er voor dat men maximaal 64 verschillende codes kon gebruiken. Dat volstond voor enkele (9) stuurcodes, de cijfers 0...9, 26 HOOFDLETTERS, 19 leestekens en andere typografische karakters.

Helaas geen kleine letters, waardoor de teksten bijzonder sterk op telexberichten leken; voor echte tekstverwerking was dit systeem nog niet geschikt (deze tabel bevatte bijvoorbeeld niet eens een vraagteken???).
 

IBM breidde het reeds uitgebreide BCD systeem met nog eens twee bits uit en noemde dit de EBCDIC-code, de Extended Binary Coded Decimal(s) Interchange Code.

Hierdoor kon men nu in totaal 256 verschillende codes weergeven (dus ook alle kleine letters, accenttekens en veel meer stuurcodes) en kwam de bitlengte perfect overeen met 1 rechtstreeks adresseerbare geheugeneenheid van de IBM-computers van toen, de byte.

Deze manier om alfanumerieke gegevens voor te stellen is lange tijd het systeem bij uitstek geweest voor mainframe computers.

Ondertussen werkte men op het niveau van microcomputers ook reeds met een karakterset die o.a. ook kleine letters aankon. Deze tabel met de welluidende naam American Standard Code for Information Interchange, de ASCII-tabel dus, was in oorsprong een tabel met bitlengte 7.

Ook met 128 verschillende codes had men in principe voldoende codes ter beschikking voor alle belangrijkste tekens en stuurcodes. Deze oorspronkelijke versie van de tabel wordt ook wel eens de ASCII-7 of standaard ASCII-tabel of lower ASCII-tabel genoemd.

Bemerk de expliciete verwijzing in de naam van de tabel naar het begrip standaardisering en informatie uitwisseling.

"Waarom niet meteen alle 8 bits van een byte gebruiken?" zal de geïnteresseerde lezer zich terecht afvragen. Het antwoord zit hier in een truukje dat men wilde toepassen om minimale fouten bij de gegevensuitwisseling op te sporen.

Het achterliggend idee is vrij eenvoudig: zorg er voor dat elke groep van 8 bits die je doorstuurt steeds een even aantal bits bevat die "aan" staan. Van de 7 eerste bits (de standaard ASCII-waarde in dit geval) tel je dus het aantal bits op die "aan" staan. Als dit aantal reeds even is dan voeg je een achtste bit toe (de pariteitsbit) met de waarde "uit"; als dat aantal echter oneven is, voeg dan een achtste bit toe met de waarde "aan".

Op die manier kan de ontvangende partij, door het nagaan van de pariteit van het aantal bits in een byte, steeds nagaan of er tijdens het transport niet stiekem één bit van waarde gewijzigd is.

Dubbele fouten kunnen hierdoor echter niet ontdekt worden, maar in de regel is dit reeds een vrij goede foutencontrole. Als er op die manier een fout ontdekt wordt, zal het systeem meestal zelf om een her-transmissie van het bewuste datapakket vragen.

In het bovenstaande geval spreken we van het systeem van de even-parity.
Je kan evengoed beide systemen zodanig instellen dat er gechecked wordt op een oneven aantal "aan"-bits per byte: dan spreken we van odd-parity.

In sommige oudere gevallen van datatransmissie via modems moest je nog in de installatiefase de juiste pariteitscontrole instellen.

Het systeem van pariteitscontrole kan echter met evenveel gemak toegepast worden op alle vormen van datatransmissie, ongeacht de oorspronkelijke bitlengte. Het enige wat er moet gebeuren is dat er één pariteitstbit aan het oospronkelijke pakketje wordt toegevoegd, en dit er bij het ontvangen uiteraard weer wordt agfehaald na controle, vooraleer met de inhoud ervan verder te werken.

Zo is het perfect mogelijk om ook de codes uit het EBCDIC-systeem via een systeem van pariteitscontrole door te geven. In dat geval werk je gewoon met groepjes van 9 bits (8 databits en 1 pariteitsbit).

De huidige datatransmissie is ondertussen echter fel verbeterd en er worden ondertussen complexere vormen van foutencontrole gebruikt.
 

Toen IBM zich ook op de markt van de microcomputers stortte met hun Personal Computer konden ze de luxe van hun EBCDIC-code moeilijk missen. Dus breidden ze de ASCII-tabel uit van een bitlengte van 7 naar 8, waardoor weer dubbel zoveel tekens gebruikt konden worden.

Deze uitbreiding (ook wel eens de hogere helft van de ASCII-tabel genoemd) kent echter vele lokale varianten om tegemoet te komen aan de noden van verschillende talen. Hierdoor kan een specifiek teken toch weer eens foutief afgedrukt worden.
 

Nog een vaak gebruikte code-tabel is de ANSI-code, ontworpen door het American National Standards Institute. Deze tabel met bitlengte 8 had specifieke stuurcodes voor het aansturen van beeldschermen.
Microsoft adopteerde deze tabel later als de ANSI-tekenset voor Windows.
 

Met de mondialisering van de informatica en de grotere behoefte aan internationale uitwisseling van gegevens heeft men meer en meer nood aan het uitschakelen van allerlei dialectische implementaties van karaktersets. De ISO (International Standardisation Organisation) heeft met die bedoeling een aantal karaktersets gedefinieerd. Vanaf de eerste versies van HTML heeft men zo goed mogelijk gepoogd om deze standaard aan te houden.
Hierdoor is het soms mogelijk om teksten uit verschillende talen toch nog via het Internet (na de aangepaste modificaties) correct op je scherm te tonen.

De karaktersets van de ISO hebben namen zoals ISO 8859-1 tot en met ISO 8859-15.

De door ons meest gebruikte (en eigenlijk ook de eerste editie), de ISO 8859-1 wordt ook vaak kortweg de ISO Latin-1 genoemd, en bevat de meeste accenttekens en valutasymbolen voor Noord Amerika, West Europa (exclusief de Baltische staten), Latijns Amerika, de Carraïben en Zuid en Centraal Afrika. Het Latin-gedeelte wijst er op dat de karakterset afgeleid is van het Romeinse alfabet dat in de meeste talen gebruikt wordt.
 

Het enige goede aan al die verschillende ISO-karaktersets is dat ze voor het weergeven van de tekens van de oorspronkelijke (lower)ASCII-tabel gelukkig allemaal dezelfde waarde gebruiken. Zolang je je dus maar houdt aan de "normale" letters en leestekens zullen je documenten overal ongeveer goed leesbaar zijn.

Dit geldt bijvoorbeeld ook voor e-mails. Speciale tekens in e-mails durven bij de ontvanger wel eens verkeerd weergegeven worden.
 

Onder druk van het internationaal karakter van het internet wordt momenteel UNICODE als de toekomstige karakterset voorgesteld. Elk karakter wordt daarin voorgesteld door een bitlengte van 16, dus twee bytes. Ook in de unicode karakterset is de oorspronkelijke ASCII-karakterset opgenomen als een echte deelverzameling. Maar daarnaast is er nu ook plaats voor Arabische, Indische en Koreaanse tekens. De fabrikanten van de "grote tekstverwerkers" maken zich nu reeds op om met UNICODE overweg te kunnen.
 

Wanneer we een databank ontwerpen gebruiken we vaak karakterstrings. Het is belangrijk deze niet onnodig lang te kiezen. Access zal bijvoorbeeld standaard een lengte van 50 karakters voorstellen wanneer je aangeeft dat je een veld van het type "tekst" wenst te gebruiken. Deze waarde kan je verkleinen tot 1 en uitbreiden tot ........ (zoek dit eens op).

Ook als je programma's schrijft waarin je karakterstrings wenst te gebruiken zal je ergens moeten aangeven hoe groot die wel moeten zijn. Op basis van die informatie kan de computer dan de nodige geheugenruimte reserveren.

In Turbo Pascal zal je bijvoorbeeld via:

var

  MijnTekstVariabele : string(39);

aangeven dat je een variabele wenst te gebruiken waarin je tot maximum 39 alfanumerieke tekens wenst te plaatsen. Turbo Pascal zal in dit geval echter een reeks van 40 bytes reserveren.

Ter info: Turbo Pascal gebruikt om karakterstrings voor te stellen de uitgebreide ASCII-tabel.

Opdracht: ga na waarom Turbo Pascal steeds die ene byte meer reserveert voor een karakterstring. Waarvoor wordt die extra byte dan gebruikt?

De hexadecimale voorstelling kan gebruikt worden als een zeer handige en beknopte voorstelling van binaire getallen. Dit komt omdat men met 1 hexadecimaal teken precies de waarde kan weergeven van een bitstring van 4 bits lang. Met andere woorden, de binaire inhoud van 1 byte kan perfect voorgesteld worden door 2 hexadecimale tekens, bijvoorbeeld:

11101011₍₂₎ = EB₍₁₆₎

Het mag hierbij duidelijk zijn dat mensen allicht veel minder fouten zullen maken bij het overnemen van de hexadecimale voorstelling dan met de binaire voorstelling.
Om die reden zie je dan ook dat wanneer, om reden van bijvoorbeeld het optreden van een fout in een computerprogramma, de reële inhoud van bepaalde geheugenplaatsen aan de gebruiker getoond wordt, niet in de binaire maar in de hexadecimale vorm.

Naar de [ homepage zonder frames ]    naar de [ homepagina met frames ].
Naar de [ vorige logische pagina in deze reeks ]     Naar de [ volgende logische pagina in deze reeks ]
Voor commentaar, vragen of suggesties i.v.m. deze pagina ben je steeds welkom bij [ Lucas De Cocker ], lector mediakunde en informatica, K.L. Ledeganckstraat 8, B-9000 Gent. [ E-mail = Lucas.DeCocker@Hogent.be ].
 
Het gebruik van dit document is onderworpen aan de wetten op het auteursrecht ©. Wens je deze inhoud (of delen ervan) te kopiëren of op een andere manier te vermenigvuldigen, aarzel dan niet om met mij contact op te nemen.