De meeste ontwikkelaars behandelen het geheugen als een zwarte doos. Ze gaan ervan uit dat variabelen slechts namen zijn die aan waarden zijn gekoppeld. Dat werkt totdat je code moet schrijven die gegevens rechtstreeks op machineniveau manipuleert. Dan druk je op pointers.
Een normale variabele is eenvoudig. Het is een stuk geheugen met een naam die u in uw code gebruikt. Declareer een geheel getal i, en de compiler reserveert vier bytes. Je ziet i. De machine ziet een adres. De waarde zit in die vier bytes.
Pointers doorbreken dat eenvoudige model.
Een aanwijzer heeft geen waarde. Er staat een adres op. Het verwijst naar een andere variabele. Concreet slaat het de geheugenlocatie van die variabele op. Dit onderscheid is van cruciaal belang. Als u deze twee door elkaar haalt, crasht uw programma. Moeilijk.
De structuur is dubbellaags. Ten eerste is er de pointervariabele zelf. Het bevat een numeriek adres. Ten tweede is er de doelvariabele. Het adres in de pointer leidt u naar de daadwerkelijke gegevens. Zodra u deze scheiding begrijpt, ontgrendelt u een aanzienlijke kracht in het programmeren van systemen.
Beschouw dit standaard C-voorbeeld:
De eerste regel declareert twee standaard gehele getallen, i en j. De volgende regel, int *p, declareert een pointer. Het sterretje is de sleutel. Het vertelt de compiler dat p geen geheel getal is. Het is een verwijzing naar een geheel getal. Je kunt dit doen met drijvers, structuren, karakters of iets anders. De syntaxis blijft hetzelfde.
Dan komt het gedeelte waar beginners over struikelen: p = &i;.
In C is het ampersand & de adresoperator. &i retourneert niet de waarde van i. Het retourneert het geheugenadres waar i zich bevindt. De toewijzing p = &i kopieert dat adres naar de pointer p. Nu wijst p naar i.
Als u deze stap overslaat, bevat p rommel. Het bevat een willekeurig, ongedefinieerd adres. Als u er later geen verwijzingen naar maakt, zal dit waarschijnlijk een segmentatiefout veroorzaken. Het programma crasht omdat u het opdracht hebt gegeven om toegang te krijgen tot geheugen waarvan het niet de eigenaar is.
Visualisatie helpt. Stel je het geheugen voor als een raster.
Vóór initialisatie bestaan i, j en p maar hebben onbekende waarden. De gehele getallen zijn vakjes met vraagtekens. Ze konden van alles bevatten. De aanwijzer p is een cirkel. Het heeft pijlen die in willekeurige richtingen wijzen. Het weet nog niet waar het heen moet.
Nadat u p = &i uitvoert, veranderen de pijlen. Ze verwijzen allemaal rechtstreeks naar i. p weet nu precies waar i woont.
De relatie is duidelijk. p bevat de locatie. i bevat de gegevens. Je gebruikt p om i te bereiken.
Dit mechanisme is hoe C het geheugen efficiënt beheert. Hiermee kunnen functies variabelen wijzigen die door verwijzing worden doorgegeven. Het maakt dynamische geheugentoewijzing mogelijk. Hiermee kunt u complexe gegevensstructuren bouwen, zoals gekoppelde lijsten en bomen.
Maar het introduceert ook risico’s. Eén verkeerd adres, en je leest of schrijft in de leegte.
Het sterretje in *p = 5 doet iets anders dan dat in int *p. Het tweede sterretje maakte deel uit van de typedefinitie. Het declareerde de variabele als een pointer. Het eerste sterretje is de dereferentie-operator. Het betekent “ga naar het adres dat is opgeslagen in p en verander daar de waarde.”
Dus *p = 5 plaatst het getal 5 in de geheugenlocatie waarnaar p verwijst. Omdat p naar i wijst, wordt i 5. De variabele j krijgt dan de waarde i. De uitvoer wordt afgedrukt 5, 5 en 5. Alle drie weerspiegelen dezelfde onderliggende verandering.
Als u wilt begrijpen hoe C-aanwijzers werken, moet u uw manier van denken veranderen. Denk niet langer aan variabelen als containers. Begin ze als locaties te beschouwen. De aanwijzer is de kaart. De variabele is de bestemming. Als de kaart verkeerd is, raak je verdwaald. En bij programmeren op laag niveau is verdwalen duur.
De indirecte operator uitgelegd
Wanneer je het adres i aan p toewijst, geef je dat ene geheugenblok feitelijk twee verschillende namen. De variabele i verwijst er nog steeds rechtstreeks naar, maar p dient nu als handvat, een referentiepunt om dezelfde gegevens te bereiken.
In C definieert deze dualiteit hoe pointervariabelen functioneren. De aanwijzer zelf, p, is eenvoudigweg een container met een adres. Het bevat niet de werkelijke waarde waarin u geïnteresseerd bent. In plaats daarvan bevat het de locatie waar die waarde leeft. Dit is waar de indirectie-operator * in beeld komt.
Door gebruik te maken van *p krijgt u toegang tot de gegevens op het adres dat is opgeslagen in p. Zie het als dereferentie. Als u *p = 5 schrijft, wijzigt u het adres binnen p niet. Je gaat naar de locatie waar p naar verwijst en de waarde die daar staat, overschrijft met het getal 5.
Dit onderscheid is van cruciaal belang voor het begrijpen van geheugenbeheer. p vertelt je waar je moet kijken. *p vertelt je waar je naar moet kijken. Het verwarren van deze twee leidt tot bugs die moeilijk op te sporen zijn, omdat je uiteindelijk een adres kunt wijzigen in plaats van de gegevens, of kunt proberen naar een willekeurige geheugenlocatie te schrijven omdat p niet correct is geïnitialiseerd.
Als je eenmaal vertrouwd bent met dit mentale model, zijn verwijzingen niet langer abstracte syntaxis, maar vormen ze een directe verbinding met het geheugen. U kunt variabelen over verschillende bereiken wijzigen, grote structuren ter referentie doorgeven zonder ze te kopiëren, en dynamische datastructuren bouwen die naar behoefte groeien en krimpen. Het is krachtig spul, als je eenmaal stopt met vechten tegen de syntaxis.
Het onderstaande codefragment illustreert dit exacte gedrag en laat zien hoe de waarde van i alleen verandert omdat p wordt gebruikt om deze te bereiken.
De waarde van i wordt onmiddellijk bijgewerkt. Het adres is niet verplaatst. Alleen de inhoud heeft dat.
Hoe pointers waarden en adressen opslaan
Het lijkt eenvoudig genoeg, maar de mechanismen kunnen je laten struikelen. Omdat aan de variabele i de waarde 5 is toegewezen, en de pointer p het adres i bevat, levert het verwijderen van de verwijzingen naar p (*p ) 5 op. Wanneer u j = i; uitvoert, kopieert u die waarde. Dus j wordt 5.
Voer nu de printf -instructie uit. Je krijgt ‘5 5 5’.
Dit gebeurt vanwege het dubbele karakter van pointers. Beschouw ze als twee verschillende rollen. Ten eerste slaat de pointervariabele zelf een geheugenadres op. Ten tweede verwijst het naar een specifiek gegevenstype dat zich op dat adres bevindt.
In ons voorbeeld:
– p is de aanwijzer. Het bevat de geheugenlocatie.
– *p is de waarde. Het zijn de daadwerkelijke gegevens die op dat adres zijn opgeslagen.
Het verwarren van de twee leidt tot bugs. Als u het adres als gegevens behandelt, krijgt u ongewenste waarden. Als u de gegevens als adres behandelt, crasht uw programma. Weten met welke je te maken hebt, verandert alles.
Waarom is dit onderscheid van belang voor de dagelijkse codering? Omdat het begrijpen van het verschil tussen waar gegevens zich bevinden en welke gegevens u in staat stelt het geheugen rechtstreeks te manipuleren. Dit is handig voor dynamische constructies, maar gevaarlijk als je de stap mist. Eén verkeerde beweging en het systeem probeert te lezen vanaf een niet-bestaande locatie.
Je begint te begrijpen waarom C in gelijke mate krachtig en gevaarlijk blijft.
