De vorige keer gaf ik deze link, van waaruit je toegang krijgt tot bijzonder goede uitleg over hoe hardware werkt. Met name, in dit geval, geheugen.

Om nu terug te keren naar C, moeten we nog even doorpraten over geheugen. In veel boeken en cursussen over programmeren worden variabelen en geheugen min of meer als losstaand behandeld. Ik heb een paar afleveringen geleden het idee van een variabele al benoemd, maar wat is zoiets nu echt?

Toen ik een jaar of 45 geleden BASIC leerde, was het verhaal dat je je een variabele moet voorstellen als een doosje waar je informatie in kan doen. Dat doosje staat ergens in het geheugen van de computer, maar waar precies doet er niet zo toe. Voor BASIC en veel moderne 'hogere' talen klopt dat redelijk. Die talen leveren een abstractie van de werkelijkheid, waarbij het geheugen vrijwel volledig buiten beeld is gekomen. Dus het beeld van een doosje met informatie werkt dan best goed.

C biedt echter een paar abstractielagen minder. Om goed te begrijpen wat je met een programma doet, moet je begrijpen dat C een variabele niet behandelt als een doosje met informatie, maar als een label dat naar een geheugenplaats verwijst. Het type van de variabele bepaalt naar hoeveel bytes je kijkt en hoe die bytes verwerkt worden; maar het is geen afzonderlijk doosje, afgescheiden en beschermd door C.

Computergeheugen zien we veelal als een rij bytes, van 8 bits. Andere formaten kunnen ook, maar in C is een byte een gebruikelijke eenheid. Met 8 bits kan je waarden van 0 tot 255 aanduiden. Bij computers is het redelijk gebruikelijk om dat niet in decimale cijfers te doen, maar in hexadecimale cijfers, die lopen van 0..F. De waarde van een byte kan dan variëren tussen 0x0 en 0xFF. Het voorvoegsel 0x geeft aan dat het hexadecimalen zijn en FF = (15*16^1 + 15*16^0) = 255. Stel nu dat je de volgende waarden in het geheugen hebt staan:

Adres	Waarde	Variabele
0000	0x01	A (char) en B (word)
0001	0x00	B (word)
0002	0xFF
0003	0x00

(Ik laat even de vraag los of een variabele van hoog naar laag of van laag naar hoog leest, ik kies hier voor big-endian, omdat dat het makkelijkste leest.) Als een variabele een doosje zou zijn, dan zou dit niet kunnen. Maar een variabele is geen doosje, maar een label. Voor C is het geen principieel probleem wat we hier zien. C kan rechtstreeks bij de geheugenplaatsen 0002 en 0003 en de overlappende variabelen A en B kunnen ook gewoon.

Dan krijg je:

A == 0x01 == 1
B == 0x0100 == 256

Stel nu dat je ergens A++ doet, dan krijg je

A == 0x02 == 2
B == 0x0200 == 512

Kortom, B verandert mee! Dat klinkt vrij absurd, wiskundig gezien, en in de meeste hogere programmeertalen waar variabelen doosjes zijn kan dit ook niet. In C is het geen probleem, hooguit is het een uitdaging om A en B te laten overlappen. Je doet dat met een

union { char a; short b; }

maar dat is nu nog niet van belang.