C maakt arrays en pointers onafscheidelijk. Je kunt geen effectieve code schrijven zonder de relatie ervan te begrijpen. Het kost tijd om het onder de knie te krijgen. De uitbetaling is onmiddellijke controle over het geheugen.
Overweeg een basisopstelling. Je declareert twee integer-arrays van grootte tien.
Stel dit samen. Het mislukt. U kunt de ene array niet aan de andere toewijzen met behulp van het gelijkteken. C ondersteunt geen bulkkopiëren via toewijzingsoperatoren. Om a naar b te kopiëren, moet je elk element doorlopen.
Je zou die lus tot één regel kunnen comprimeren met een komma-operator, maar de leesbaarheid lijdt eronder. De standaardaanpak is om memcpy uit string.h te gebruiken. Het verwerkt de kopie op byteniveau efficiënt.
Het falen van b=a onthult een fundamentele regel. In C zijn arrayvariabelen geen arrays. Het zijn vaste aanwijzingen. a en b zijn permanente identificatiegegevens voor het startadres van hun respectievelijke geheugenblokken. a verwijst naar a[0]. b verwijst naar b[0]. Deze adressen zijn onveranderlijk. U kunt een variabelenaam niet omleiden naar een andere geheugenlocatie. Daarom mislukt de opdracht. De compiler behandelt de arraynaam als een constante pointer.
Omdat de naam in feite een pointer is, kunt u pointer-berekeningen gebruiken om toegang te krijgen tot gegevens. Dit is waar de syntaxis krachtig wordt.
Hier is p een pointervariabele. U kunt het adres van array a toewijzen aan p. De verklaring p=a kopieert het adres. Nu heeft p dezelfde waarde als de arraynaam a. Door p te derefereren met *p wordt het eerste element opgehaald. De output is nul.
Dit onderscheid is van belang omdat pointervariabelen kunnen worden gewijzigd. Je kunt p met behulp van rekenkunde naar a[1] of a[5] laten verwijzen. De arraynaam zelf blijft aan het begin hangen. Dankzij deze flexibiliteit kunnen functies door het geheugen itereren zonder grote datastructuren te kopiëren. Het is de ruggengraat van prestaties op laag niveau in C.
Als u deze link begrijpt, voorkomt u subtiele bugs. Het verklaart waarom sommige functies pointers accepteren in plaats van array-syntaxis. Het verduidelijkt de geheugenindeling. Negeer het en u zult te maken krijgen met segmentatiefouten of onbedoelde gegevensoverschrijvingen. Leer het en je ziet precies wat de machine doet.
De syntaxis kan in eerste instantie onnatuurlijk aanvoelen. De dubbele betekenis van haakjes en sterretjes brengt beginners in verwarring. Maar zodra het model klikt, verdwijnt de abstractie. Je houdt adressen en waarden over. Niets meer.
Is het de mentale inspanning waard? De code wordt sneller. Het geheugengebruik daalt. U krijgt directe toegang tot bewerkingen op hardwareniveau. De meeste C-programma’s zijn afhankelijk
U kunt een arrayvariabele rechtstreeks aan een pointer toewijzen, omdat deze onder de motorkap in wezen hetzelfde zijn.
p=a; werkt niet vanwege magie, maar omdat a vervalt in een aanwijzer. Concreet verwijst het naar het geheugenadres van het eerste element van de array (index 0). Omdat dat element een geheel getal is, fungeert a als een verwijzing naar een enkele int. Als u p declareert als een integer-aanwijzer en deze gelijk stelt aan a, laat u eenvoudigweg twee variabelen hetzelfde adres delen. Je zou in plaats daarvan p=&a[0]; kunnen schrijven. Het resultaat is identiek.
Zodra p is aangesloten op het begin van a, wordt u mobiel. Arraynamen zoals a zijn constanten; het zijn vaste adressen die niet kunnen veranderen. Aanwijzingen zoals p zijn anders. Je kunt ze verplaatsen met behulp van pointer-berekeningen.
Dit is waar C slim wordt.
Wanneer u p++; schrijft, voegt de compiler niet slechts één byte toe aan het adres. Het weet dat p naar een geheel getal verwijst. Het voegt in plaats daarvan sizeof(int) bytes toe en komt precies op het volgende element terecht. Als p naar een structuur van 100 bytes lang zou verwijzen, zou p++ 100 bytes vooruit springen. C verzorgt de wiskunde. Je verplaatst gewoon de aanwijzer.
Arrays kopiëren zonder indexen
Met behulp van deze pointers kunt u de ene array naar de andere kopiëren. In plaats van een standaardlus met indexen:
U kunt aanwijzingen gebruiken:
Het is uitgebreid. Je kunt het comprimeren.
Of vouw het samen tot één enkele regel.
De prioriteit van de machinist is hier zwaar tillen. * heeft een hogere prioriteit dan ++, maar de post-increment vindt plaats nadat de waarde is opgehaald. Dus *p++ haalt de huidige waarde op en verplaatst vervolgens de aanwijzer. *q++ doet hetzelfde voor de bestemming. De opdracht gebeurt tussendoor. Het is compact. Het is snel. Het is ook gemakkelijk om verkeerd te lezen als je niet oplet.
De gevarenzone
Wat gebeurt er als je p of q voorbij het einde van de array duwt?
C houdt je niet tegen.
De compiler gaat ervan uit dat u weet wat u doet. Het blijft de pointers verhogen en gegevens naar het geheugen kopiëren die niet tot de array behoren. Mogelijk overschrijft u andere variabelen. Mogelijk beschadigt u de stapel. Mogelijk crasht het programma later op een plek die niets met de bug te maken heeft.
Daarom is de grenscontrole handmatig in C. De taal vertrouwt je. Wanneer u buiten de lijn stapt, betaalt u de prijs.
Arrays doorgeven aan functies
U kunt op twee manieren arrays aan functies doorgeven. Ze zien er anders uit, maar gedragen zich hetzelfde.
Beschouw een functie die een array afdrukt:
Of de pointerversie:
De parameter nia (nummer in array) is verplicht. Arrays in C dragen hun grootte niet met zich mee. De functie moet weten wanneer hij moet stoppen.
In beide gevallen geeft u een verwijzing door naar het begin van de array, maar niet
