Pointers en geheugenadressen in C

Je kunt geheugen voorstellen als een reeks genummerde bytes. Elk nummer is een adres. Een object zoals een int neemt opeenvolgende bytes in en het adres duidt de eerste byte aan. Via de naam die je in de broncode gebruikt, kan de compiler dat object vinden; de taal vereist niet dat naast de waarde een naamlabel wordt opgeslagen.

Meet opslag met sizeof

sizeof geeft het aantal bytes en levert een waarde van het type size_t op. Gebruik %zu om die af te drukken:

int scores[4] = {12, 18, 15, 21};
printf("%zu %zu\n", sizeof scores, sizeof scores[0]);

Bij int-waarden van 4 bytes drukt dit 16 4 af. Het eerste resultaat meet alle vier de elementen; het tweede meet er één. sizeof(char) is altijd 1. Een gangbare indeling op een 64-bits desktop gebruikt int-waarden van 4 bytes, double-waarden van 8 bytes en objectpointers van 8 bytes. Op andere doelsystemen kan dit verschillen. Ook bij 64-bitssystemen neemt long op Linux en macOS vaak 8 bytes in, maar op Windows 4.

Opslaggrootte en tekstlengte beantwoorden verschillende vragen. Voor char word[20] = "hi"; is sizeof word gelijk aan 20, terwijl strlen(word) 2 is. De array bevat nog steeds 20 elementen, hoewel de string maar twee letters en een afsluitend nulteken gebruikt. Behalve bij arrays met variabele lengte liggen deze objectgroottes vast tijdens de compilatie.

Volg de adressen van een array

Hexadecimale adressen gebruiken de cijfers 0 tot en met 9 en daarna a tot en met f. Het voorvoegsel 0x duidt grondtal 16 aan. Voor een voorbeeldarray die begint op 0x1000, beginnen vier elementen van 4 bytes op:

0x100C is decimaal 4.108, twaalf bytes voorbij 0x1000. Tussen arrayelementen zit geen ruimte. Voor afzonderlijk gedeclareerde variabelen is geen volgorde of afstand gegarandeerd; ook echte afgedrukte adressen kunnen tussen uitvoeringen veranderen. Een compiler kan een waarde in een processorregister bewaren als geen adresseerbare opslag nodig is.

Uitlijning en bytevolgorde

Uitlijning beperkt waar objecten van een type kunnen beginnen. Een gangbare indeling plaatst int-waarden van 4 bytes op veelvouden van 4 en double-waarden van 8 bytes op veelvouden van 8. De compiler zorgt voor een geschikte uitlijning van gedeclareerde objecten.

Bytevolgorde is de volgorde van bytes binnen een waarde die uit meerdere bytes bestaat. Voor een unsigned int van 4 bytes met 0x12345678 staan bij little-endianopslag de bytes 78 56 34 12 van lage naar hoge adressen; bij big-endianopslag zijn dat 12 34 56 78. Met een unsigned char * kun je de representatie van een object byte voor byte bekijken. De bytevolgorde verandert de indexvolgorde van de array niet.

Houd het object in leven

Een gewone lokale variabele heeft automatische opslagduur: haar levensduur duurt zolang haar blok wordt uitgevoerd. Gangbare implementaties bewaren zulke objecten in het stackframe van een aanroep en gebruiken die opslag daarna opnieuw. Globale variabelen, static-variabelen en stringliterals bestaan gedurende het hele programma. Een adres opslaan verlengt de levensduur van het object niet.

Een pointer slaat een adres op en heeft een type dat het object beschrijft waartoe die toegang kan krijgen. Als je een int * declareert, krijg je opslag voor een pointer; je maakt daarmee geen int die de pointer kan gebruiken. Geef de pointer een bekende waarde wanneer je die declareert.

Vraag het adres van een object op

int count = 42;
int *p = &count;

De unaire adresoperator & vraagt het adres van count op. Als count begint op het voorbeeldadres 0x1000, bevat p de waarde 0x1000, terwijl count 42 bevat. De pointer is ook een object: &p is het adres van de afzonderlijke opslag die die pointer bevat.

Je kunt het adres van een arrayelement opvragen, zoals &scores[2]. Een numerieke constante of een berekeningsresultaat is geen opgeslagen object waarvan je op deze manier het adres kunt opvragen: &42 en &(count + 1) zijn ongeldig. De binaire expressie a & b gebruikt hetzelfde symbool voor een bitsgewijze EN; het aantal operanden vertelt je welke bewerking wordt bedoeld.

Lees elke declarator

Witruimte verandert geen van deze typen. int* p en int *p zijn gelijkwaardig. Als je één pointer per regel declareert, zie je de ster minder snel over het hoofd. Op gangbare 64-bits desktops neemt een objectpointer 8 bytes in, maar de eigen grootte vertelt je niet hoe groot het object is waarnaar de pointer wijst.

Het type van het doelobject is belangrijk. Gebruik voor double price = 9.5; de declaratie double *r = &price;. Als je een int * initialiseert met &price, krijg je een melding over incompatibele pointers. Een expliciete typeconversie die de melding verbergt, maakt een toegang tot die double als int niet geldig: het type bepaalt hoe de opgeslagen bytes worden benaderd.

Laat een pointer naar iets anders wijzen

int a = 5, b = 8;
int *p = &a;
p = &b;

De laatste toewijzing vervangt het adres in p. Geen van beide gehele getallen wordt verplaatst en de waarde van het ene getal wordt niet naar het andere gekopieerd. Nu wijst p naar b; a is nog steeds 5 en b nog steeds 8. Meerdere pointervariabelen kunnen ook hetzelfde adres opslaan.

Gebruik een bekende lege toestand

Een niet-geïnitialiseerde lokale pointer heeft een onbepaalde waarde en wordt soms een wilde pointer genoemd. Bekijk of derefereer die niet. Initialiseer de pointer met het adres van een geldig object of met NULL, beschikbaar via onder meer de headers <stddef.h> en <stdio.h>:

int *pending = NULL;
if (pending == NULL) {
    pending = &count;
}

Een nulpointer duidt geen object aan. !pending is een andere test op een nulpointer. Deze tests zijn alleen zinvol voor geïnitialiseerde pointers; ze valideren geen willekeurig adres of pointer waarvan het object niet meer bestaat.

Druk een objectpointer af

printf("%p\n", (void *)p);

%p verwacht void *, dus gebruik de expliciete typeconversie bij een getypeerde objectpointer. De implementatie kiest de afgedrukte representatie; die is meestal hexadecimaal. %d en %x verwachten gehele getallen van bepaalde typen als argumenten en kunnen %p niet vervangen.

De unaire dereferentieoperator * volgt een pointer naar het bijbehorende object. Als p naar x wijst, duidt *p de variabele x zelf aan. Als je *p leest, lees je dat object; als je een waarde toewijst aan *p, wijzig je het object.

Volg een schrijfbewerking via een adres

int x = 10;
int *p = &x;
*p = *p + 5;
int y = *p * 2;
printf("%d %d %d\n", x, *p, y);

Eerst slaat p het adres van x op. Aan de rechterkant van de toewijzing leest *p de waarde 10. Als je er 5 bij optelt, krijg je 15 en de *p aan de linkerkant slaat 15 op in x. De volgende regel vermenigvuldigt de bijgewerkte waarde met 2, zodat y gelijk wordt aan 30. De uitvoer is 15 15 30.

De context onderscheidt de sterren: int *p declareert een pointer, de unaire expressie *p benadert een object en *p * 2 bevat ook een binaire vermenigvuldiging. Voor een geldig object x duidt *&x de variabele x aan; voor een pointer naar een geldig object geeft &*p de pointerwaarde terug.

Houd adressen en inhoud uit elkaar

Begin elk uitvoeringsspoor met twee rijen informatie: welk adres elke pointer bevat en welke waarde elk geheel getal bevat. Stel dat p naar a wijst, met waarde 3, en q naar b, met waarde 8.

Een geheugendiagram gebruikt voor elk object een vak. Zet de naam en het adres bij het vak, zet de huidige waarde erin en teken een pijl van een pointer naar het doelobject. Een adrestoewijzing verplaatst een pijl; een toewijzing aan het object waarnaar wordt gewezen verandert de inhoud van het doelvak.

Na p = q zijn de pointers aliassen van b. Als je daarna *p = 20; uitvoert, levert het lezen van *q of b de waarde 20 op. Een adres kopiëren maakt een extra route naar hetzelfde object, geen extra geheel getal.

Controleer of derefereren geldig is

Een pointer die voor toegang wordt gebruikt, moet een bestaand object van een geschikt type aanduiden en schrijven vereist bovendien een wijzigbaar object. Nulpointers duiden geen object aan. Niet-geïnitialiseerde pointers hebben geen bekend bruikbaar doelobject. Een pointer wordt ongeldig wanneer de levensduur van het doelobject eindigt.

Toegang via een ongeldige pointer is ongedefinieerd gedrag: C stelt geen eisen aan het resultaat. Het programma kan stoppen met een segmentatiefout, gegevens beschadigen of normaal lijken te werken. Een schijnbaar geslaagde uitvoering bewijst niet dat de toegang geldig was.

Test een pointer die terecht een nulpointer kan zijn voordat je die gebruikt voor toegang:

if (p != NULL) {
    *p = 0;
}

Door NULL toe te wijzen aan een pointer die je niet meer nodig hebt, kun je voorkomen dat je die variabele later per ongeluk gebruikt. Daarmee stel je andere aliassen niet opnieuw in. Houd de levensduur van het object afzonderlijk bij.

Zet haakjes om de bedoelde waarde

De postfixoperator ++ bindt sterker dan de unaire *. Daarom betekent *p++ hetzelfde als *(p++): de expressie gebruikt de oude pointer om een waarde te bereiken en schuift de pointer op. (*p)++ verhoogt de waarde waarnaar wordt gewezen en laat de pointer staan. *p + 1 leest de waarde en telt er 1 bij op zonder het resultaat op te slaan. Dit zijn drie verschillende handelingen.

C geeft elk argument op waarde door. Een parameter is een lokale variabele die met het argument wordt geïnitialiseerd. Een adres doorgeven verandert die regel niet: de functie ontvangt een kopie van het adres en kan met die kopie het object van de aanroepende functie bereiken.

Vergelijk twee resetfuncties

void reset_copy(int n) {
    n = 0;
}

void reset(int *n) {
    *n = 0;
}

Voor int score = 12; wijzigt reset_copy(score) alleen de lokale n. score blijft 12. De aanroep reset(&score) kopieert het adres van score naar pointerparameter n; een toewijzing aan *n verandert vervolgens score in 0. Deze techniek heet vaak doorgifte via verwijzing, hoewel de taal de argumenten daadwerkelijk op waarde blijft doorgeven.

Het adres in de aanroep en de dereferentie in de functiebeschrijving hebben verschillende taken. &score vertelt de functie waar het object zich bevindt. *n = 0 vertelt wat de functie daar moet opslaan. De aanroep reset(score) levert een geheel getal waar een pointer nodig is en veroorzaakt een diagnostische compilermelding.

Doorloop een verwisseling

void swap(int *a, int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}

/* Inside a calling function: */
int x = 3, y = 8;
swap(&x, &y);

1. a wijst naar x en b wijst naar y.
2. t bewaart de oorspronkelijke waarde van x, namelijk 3.
3. *a = *b schrijft 8 naar x.
4. *b = t schrijft de bewaarde 3 naar y.

Beide variabelen van de aanroepende functie veranderen. Een versie met gewone parameters int a, int b verwisselt alleen kopieën. Ook een pointerversie die int *t = a; a = b; b = t; uitvoert, verwisselt de gehele getallen niet: die laat alleen de lokale pointerparameters naar iets anders wijzen.

Lever meer dan één resultaat

Een return-instructie levert één waarde, maar pointerparameters kunnen extra uitvoerwaarden doorgeven:

void divide(int total, int size, int *q, int *r) {
    *q = total / size;
    *r = total % size;
}

/* size must be positive for these example inputs. */
int q, r;
divide(17, 5, &q, &r);

Geheeltallige deling geeft q de waarde 3 en r de waarde 2. De aanroepende functie levert twee afzonderlijke beschrijfbare objecten. Een andere nuttige interface geeft een successtatus terug en schrijft alleen bij succes een uitvoerwaarde; aanroepende functies controleren die status voordat ze de uitvoer gebruiken.

Herken hetzelfde patroon in bibliotheekaanroepen

scanf("%d", &age) heeft het adres van age nodig omdat de functie daar een ingelezen geheel getal opslaat. Als je age doorgeeft, lever je een waarde in plaats van de vereiste int *, wat ongedefinieerd gedrag oplevert. Controleer of scanf 1 teruggeeft voordat je de nieuw ingelezen waarde gebruikt.

Voor tekst geeft char name[20]; scanf("%19s", name); een pointer naar het eerste teken van de array door. De breedte staat maximaal 19 invoertekens toe, zodat er ruimte overblijft voor '\0'. De arrayexpressie levert de vereiste tekenpointer al.

Een arrayparameter ontvangt eveneens een adres, geen gekopieerd blok elementen. In void zero(int *a, size_t n) hebben toewijzingen aan a[i] effect op de array van de aanroepende functie. Bij het doorgeven van het adres wordt alleen een pointer gekopieerd, zodat ook functies die alleen lezen grote arrays kunnen bekijken zonder elk element te kopiëren.

Een pointerinterface moet twee dingen duidelijk maken: of de functie via de pointer mag schrijven en hoelang de opslag waarnaar wordt gewezen geldig blijft. const beantwoordt de eerste vraag. De levensduur van het object beantwoordt de tweede.

Bepaal waar const de toegang beperkt

Een pointer naar een const-gekwalificeerd object beperkt deze toegang. Als x is gedefinieerd als de gewone int x = 5;, blijft x = 6; toegestaan, ook terwijl een const int * ernaar wijst. Als het object zelf als const is gedefinieerd, is een poging om het via welke pointer dan ook te wijzigen ongedefinieerd gedrag.

Een constante pointer behoudt één adres. De pointer moet worden geïnitialiseerd en het adres kan later niet worden vervangen. Het object op dat adres kan nog steeds veranderen als het type dat toestaat. Lees vanaf de naam naar buiten: int *const p maakt p constant; const int *p beschermt de int die via p wordt bereikt.

Gebruik een parameter voor alleen lezen zoals const char *s wanneer een functie een string alleen bekijkt. Je kunt een gewone char * zonder expliciete typeconversie aan die parameter doorgeven. De functie kan haar lokale s opschuiven, maar een toewijzing via *s wordt afgewezen. Terug converteren naar een beschrijfbaar type vereist meer dan een compilerwaarschuwing verwijderen: het onderliggende object moet daadwerkelijk wijzigbaar zijn.

Geef een positie in opslag van de aanroepende functie terug

int *find(int *a, size_t n, int target) {
    for (size_t i = 0; i < n; i++) {
        if (a[i] == target) return &a[i];
    }
    return NULL;
}

Voor int v[] = {4, 9, 2, 9}; geeft find(v, 4, 9) de waarde &v[1] terug. De functie eindigt, maar v behoort tot de aanroepende functie en blijft daar bestaan. Nadat die het resultaat met NULL heeft vergeleken, kan de aanroepende functie found - v berekenen om index 1 te krijgen of *found = 0 toewijzen om het element bij te werken. Een zoekopdracht naar 7 geeft NULL terug, wat je niet mag derefereren. strchr en strstr gebruiken dezelfde conventie: een nulpointer bij niet vinden.

Wijs adressen van lokale variabelen die niet meer bestaan af

int *bad(void) {
    int result = 42;
    return &result;
}

result heeft automatische opslagduur. De levensduur eindigt wanneer de aanroep terugkeert, waardoor de aanroepende functie een ongeldige pointer naar een niet meer bestaand object overhoudt. De compiler kan waarschuwen en elke latere toegang via die pointer is ongedefinieerd gedrag. Als de oude bytes bij één uitvoering zichtbaar zijn, blijft het object daardoor niet bestaan.

Hetzelfde probleem kan optreden bij de sluitende accolade van een binnenblok. Een pointer in een buitenliggend blok kan de levensduur van een variabele in een binnenblok waarvan die het adres heeft opgeslagen niet verlengen.

Kies opslag die lang genoeg bestaat

Geef een int-waarde terug wanneer de aanroepende functie alleen een geheel getal als resultaat nodig heeft. Laat de aanroepende functie voor meerdere resultaten opslag beschikbaar stellen om te vullen. Een teruggegeven pointer kan ook verwijzen naar de array van de aanroepende functie, een stringliteral die via const char * toegankelijk is, of een static-object.

Een lokale statische variabele wordt één keer geïnitialiseerd en bestaat gedurende het hele programma, maar alle aanroepen delen die variabele. Als een latere aanroep er een nieuwe waarde in opslaat, ziet elke eerder teruggegeven pointer die wijziging. Statische opslag lost het probleem met de levensduur op zonder elke aanroep een eigen onafhankelijk resultaatobject te geven.

Als je een geheel getal bij een pointer optelt, verplaats je die met elementen van het type waarnaar wordt gewezen. Als p naar arrayelement i wijst, wijst p + n naar element i + n, mits de resulterende positie binnen de array of direct erna ligt.

Schaal het adres één keer

Vanaf een voorbeeldadres 0x1000 geeft 3 optellen deze resultaten:

De compiler voert de schaling uit. Als je p + 3 * sizeof *p schrijft, schaal je twee keer en kom je meestal bij het verkeerde element uit. Gebruik unsigned char * wanneer de bedoelde stap echt één byte van de representatie van een object is.

Voor int a[6] = {10, 20, 30, 40, 50, 60}; en int *p = &a[1]; leest *(p + 2) het element a[3], dat 40 is. De toewijzing p += 3; verplaatst de pointer zelf naar a[4], dat 50 bevat. Vanaf daar leest *(p - 1) de waarde 40. p++, p--, p += n en p -= n gebruiken allemaal stappen in elementen.

Trek posities van elkaar af om elementen te tellen

&a[5] - &a[1] is 4 en als je de operanden omdraait, krijg je -4. Het resultaat telt al elementen; deel het niet door sizeof(int). Het type met teken is ptrdiff_t, gedeclareerd in <stddef.h>, en %td drukt het af.

Trek alleen pointers naar posities in dezelfde array van elkaar af, inclusief de positie direct voorbij het laatste element, met een resultaat dat in ptrdiff_t kan worden weergegeven. Deze bewerking beschrijft posities binnen die array. Adressen van niet-gerelateerde variabelen van elkaar aftrekken is ongedefinieerd gedrag, ook als de afgedrukte getallen toevallig dicht bij elkaar liggen.

Gebruik de positie direct voorbij het laatste element als grens

Voor zes elementen is a + 6 een geldige pointer direct voorbij het laatste element. Die kan als grens dienen en worden gebruikt bij geldige aftrekking binnen dezelfde array, maar kan niet worden gederefereerd. a + 7 en a - 1 zijn al ongedefinieerd gedrag wanneer ze worden gevormd; door ze later niet te derefereren herstel je dat niet.

for (int *p = a; p < a + 6; p++) {
    printf("%d\n", *p);
}

De lusinhoud wordt uitgevoerd voor de indices 0 tot en met 5. Na de laatste ophoging is p gelijk aan a + 6 en stopt de volgende test de lus. Met <= zou de lusinhoud toegang krijgen tot die positie die geen element is.

Voor de rekenregels gedraagt één object zich als een array van één element. Je mag &x + 1 vormen; je mag die pointer niet gebruiken om een vermeende volgende variabele te lezen.

Vergelijk alleen zinvolle posities

Volgordeoperatoren zoals < vergelijken posities binnen één array. Vergelijk pointers naar niet-gerelateerde objecten niet op volgorde. Gelijkheid en ongelijkheid kunnen compatibele pointertypen vergelijken en kunnen testen op een nulpointer.

Je kunt geen twee pointers optellen, pointers vermenigvuldigen of in standaard-C rekenen met een void * of een functiepointer. Om het midden van een bereik [p, q) binnen dezelfde array te vinden, gebruik je p + (q - p) / 2: trek posities van elkaar af om een aantal te krijgen, deel dat aantal en schuif dan op vanaf p.

Een array is een blok elementen. Een pointer is een afzonderlijk object dat een adres bevat. Hun nauwe relatie komt door een automatische conversie die in de meeste expressies plaatsvindt, niet doordat de twee objecten van dezelfde soort zijn.

Converteer een arrayexpressie

int a[5] = {3, 1, 4, 1, 5};
int *p = a;

Hier wordt a geconverteerd naar een pointer naar a[0]. Door deze conversie van array naar pointer is de initialisator gelijkwaardig aan &a[0]. Zowel *p als a[0] leest de waarde 3.

C definieert indexering via pointerrekenen: a[i] betekent *(a + i). Daarom werkt p[3] ook en leest die expressie de waarde 1. &a[i] en a + i duiden hetzelfde element aan. Zelfs 3[a] heeft dezelfde gedefinieerde betekenis als a[3], hoewel de gebruikelijke schrijfwijze veel duidelijker is.

Weet wanneer de hele array een array blijft

De conversie vindt niet plaats voor operanden van sizeof of de unaire &. Ze vindt ook niet plaats voor typeof en typeof_unqual in C23, of wanneer een stringliteral een tekenarray initialiseert.

Je kunt geen nieuw adres aan een array toewijzen of de naam ophogen: a = p; en a++; zijn ongeldig. Je kunt p naar iets anders laten wijzen, bijvoorbeeld met p = a + 2;. Kopieer de inhoud van een array met een lus over de elementen of een geschikte aanroep van memcpy.

Volg het omgezette parametertype

int sum(const int *values, size_t n) {
    int total = 0;
    for (size_t i = 0; i < n; i++) total += values[i];
    return total;
}

De aanroepende functie levert zowel een adres als een aantal. Voor de array hierboven bezoekt sum(a + 2, 3) de oorspronkelijke indices 2, 3 en 4 en telt 4, 1 en 5 op om 10 terug te geven. Binnen de functie is index 0 relatief ten opzichte van de opgegeven beginpointer.

In een parameterlijst van een functie declareren int a[], int a[10] en int *a allemaal een pointerparameter. De gewone schrijfwijze [10] geeft geen gecontroleerde grens en geeft geen lengte door. Binnen zo’n functie meet sizeof a een pointer. De expressie sizeof a / sizeof a[0] zou 2 opleveren op een systeem met pointers van 8 bytes en int-waarden van 4 bytes, ongeacht de werkelijke arraylengte van de aanroepende functie.

Onderscheid een elementpointer van een arraypointer

a wordt geconverteerd naar int *, terwijl &a het type int (*)[5] heeft, een pointer naar de hele array van vijf elementen. Beide duiden het begin van dezelfde opslag aan, maar berekeningen volgen hun verschillende typen. a + 1 schuift één int op, oftewel 4 bytes in deze indeling. &a + 1 schuift één hele array op, oftewel 20 bytes, naar de positie direct voorbij de array.

Een afgedrukt beginadres kan dat typeverschil niet laten zien. Lees de declaratie en houd bij het volgen van een expressie het type waarnaar wordt gewezen naast de pointer.

Een pointerlus heeft een huidige positie en een stopregel nodig. Een array met een bekend aantal elementen gebruikt een eindpointer; een string gebruikt het afsluitende '\0'. Kies de vorm die het duidelijkst laat zien welke elementen worden bezocht.

Doorloop een bereik met een bekend aantal elementen

int a[] = {3, 1, 4, 1, 5};
int total = 0;
for (const int *p = a; p < a + 5; p++) {
    total += *p;
}

De tussentotalen zijn 3, 4, 8, 9 en 14. Een lus met een index die a[i] voor indices kleiner dan 5 optelt, geeft hetzelfde resultaat. Moderne optimaliserende compilers genereren voor deze vormen vaak vergelijkbare code; pointersyntaxis op zichzelf belooft geen snelheidsvoordeel.

Lees vóór of na het verplaatsen

Als p naar de 3 in {3, 1, 4} wijst, zet int v = *p++; de waarde van v op 3 en laat die p naar de 1 wijzen. Postfixincrementatie levert de oude pointerwaarde aan * en werkt de pointer bij. *++p gaat eerst naar het volgende element en leest dat dan. (*p)++ wijzigt het huidige element en verplaatst de pointer niet.

Stop bij een afsluitend nulteken

size_t my_strlen(const char *s) {
    const char *p = s;
    while (*p != '\0') p++;
    return (size_t)(p - s);
}

Voor "pointer" stopt p op het afsluitende nulteken, zeven posities vanaf het begin. Het resultaat telt dat nulteken niet mee. Tekens tellen gebeurt met dezelfde doorloop: als je "mississippi" doorloopt en een teller verhoogt wanneer *p == 's', tel je vier overeenkomsten onder elf letters.

Een pointer naar het midden van een string geeft toegang tot het achterste deel ervan. Met const char *msg = "hello world"; drukt puts(msg + 6) "world" af. De eerdere tekens blijven staan waar ze stonden.

Kopieer ook het afsluitende nulteken

char destination[4];
const char *src = "cat";
char *dst = destination;
while ((*dst++ = *src++) != '\0') {
}

Elke iteratie wijst één teken toe, test de toegewezen waarde en schuift beide pointers op. De laatste iteratie kopieert '\0', zodat de bestemming een complete string is. Beide pointers staan dan direct voorbij hun afsluitende nulteken. De opslag vereist de tekstlengte plus één byte; als die extra byte ontbreekt, ontstaat een bufferoverloop. Dit kopieerpatroon vereist ook dat de bron- en bestemmingsbereiken niet overlappen.

Keer om vanaf beide uiteinden

Bepaal eerst de lengte van een beschrijfbare string. Als de lengte nul is, stop je voordat je een pointer naar het laatste teken vormt. Zet anders left = s en right = s + length - 1. Zolang left < right, verwissel je de tekens, verhoog je left en verlaag je right. Voor "stressed" leveren vier verwisselingen "desserts" op; het afsluitende nulteken blijft op het oorspronkelijke einde staan.

De controle op een lege string is belangrijk omdat je door 1 van de beginpointer af te trekken een pointer vóór de array zou vormen.

Kies beschrijfbare tekenopslag

char word[] = "hello"; maakt een wijzigbare array van zes bytes, inclusief het afsluitende nulteken. const char *word = "hello"; wijst naar een stringliteral met statische opslagduur. Een stringliteral wijzigen is ongedefinieerd gedrag, ook als een declaratie char * zonder const gebruikt. Gebruik const char * zodat de compiler onbedoelde schrijfbewerkingen als fout meldt.

Een arraylus moet vóór de positie direct voorbij het laatste element stoppen en een stringdoorloop moet daadwerkelijk een afsluitend nulteken binnen toegankelijke opslag tegenkomen. Een pointer bevat geen lengte en biedt geen garantie dat de bytes een string vormen.

Een pointer is een opgeslagen object en heeft dus een adres dat een andere pointer kan bevatten. Een pointer naar een pointer voegt nog een stap toe tussen de expressie en de uiteindelijke gegevens.

Volg de pijlen één voor één

int x = 7;
int *p = &x;
int **pp = &p;

Gebruik voorbeeldadressen: x op 0x2000 bevat 7; p op 0x3000 bevat 0x2000; pp op 0x4000 bevat 0x3000. De evaluatie van *pp bereikt p, waarvan de waarde het type int * heeft. De evaluatie van **pp volgt die pointer verder naar x, een int.

&p heeft één pointerniveau meer dan p; elke dereferentie verwijdert één niveau. int **pp initialiseren met &x past niet, omdat &x het type int * heeft.

Kies het niveau van de toewijzing

Als er nog een bestaand geheel getal y is, verandert **pp = 9; de waarde van x. De toewijzing *pp = &y; wijzigt de pointer p, zodat volgend gebruik van **pp de variabele y bereikt. De huidige waarde van x blijft ongewijzigd. Als q een andere int * is, wijzigt pp = &q; alleen de buitenste pointer, zodat de eerste pijl naar q wijst in plaats van naar p.

Tel niet alleen sterren, maar controleer ook het object op elk niveau. Voordat je **pp evalueert, moeten zowel de route naar het pointerobject als de route van dat object naar het gehele getal geldig zijn.

Verplaats een stringpointer van de aanroepende functie

void skip_spaces(const char **s) {
    while (**s == ' ') {
        (*s)++;
    }
}

/* In the caller: */
const char *text = "   hi";
skip_spaces(&text);
puts(text);

De aanroepende functie geeft het adres van haar pointervariabele door. *s duidt daardoor text aan; **s leest het huidige teken. Elke uitvoering van (*s)++ schuift text één teken op. Na drie iteraties wijst de pointer naar 'h' en drukt puts "hi" af. De functie vereist een geldige pointer naar een pointer die naar een positie in een string met een afsluitend nulteken wijst.

Een versie met const char *s die s ophoogt, wijzigt alleen een lokale kopie. Ook de haakjes in (*s)++ zijn noodzakelijk: *s++ verhoogt de buitenste lokale pointer in plaats van de tekenpointer van de aanroepende functie. In const char **s zijn de tekens via deze toegang alleen leesbaar, maar mag de pointer van de aanroepende functie worden verplaatst.

Lees een uitvoerpointer van een bibliotheekfunctie

strtol uit <stdlib.h> gebruikt een uitvoerparameter van het type char **:

char *end;
long number = strtol("42abc", &end, 10);

De functie geeft 42 terug en slaat in end een pointer op naar het eerste ongebruikte teken; die wijst nu naar "abc". Als de eindpointer gelijk is aan de beginpointer, zijn geen cijfers geconverteerd. Een volledig gecontroleerde omzetting van tekst naar een getal handelt ook bereikfouten af; de taak van de pointer is hier de stoppositie melden.

Een array kan pointers als elementen opslaan. Een tweedimensionale array slaat daarentegen volledige rijen als elementen op. Beide ondersteunen twee indices, maar hun opslag en de pointertypen waarnaar ze worden geconverteerd verschillen.

Sla adressen van afzonderlijke strings op

const char *days[] = {"Mon", "Tue", "Wed"};

days bevat drie tekenpointers. Elke pointer wijst naar een afzonderlijke stringliteral. days[1] is de pointer naar "Tue" en days[1][0] leest 'T'. Bij objectpointers van 8 bytes is sizeof days gelijk aan 24, ongeacht de lengte van de strings. De strings zelf nemen elders opslagruimte in.

De lengten kunnen verschillen, waardoor een verzameling met ongelijke rijlengten ontstaat. Als je de lijst opnieuw ordent, kun je pointerelementen verwisselen zonder de tekst te kopiëren. De toewijzing days[0] = "Thursday"; is toegestaan: het pointerelement kan veranderen, ook al zijn de tekens die je ermee bereikt alleen leesbaar.

In de meeste expressies wordt days geconverteerd naar een pointer naar het eerste element. Omdat een element een const char * is, is het geconverteerde type const char **:

for (const char **d = days; d < days + 3; d++) {
    puts(*d);
}

De lus schuift per iteratie één pointerelement op. *d haalt de tekenpointer op die puts nodig heeft.

Lees opdrachtregelstrings

int main(int argc, char *argv[]) ontvangt hetzelfde parametertype als char **argv. argc is niet-negatief en telt de beschikbare strings. Als de waarde positief is, stelt argv[0] de programmanaam voor, of een lege string als die naam niet beschikbaar is. Gebruikersargumenten staan op de indices 1 tot en met argc - 1 en argv[argc] is een nulpointer.

Bij een typische aanroep ./greet Ada 42 is argc gelijk aan 3, wijst argv[1] naar "Ada" en wijst argv[2] naar "42". Het laatste argument is tekst totdat een conversie zoals strtol het leest. argv[1][0] is 'A'. Controleer argc > 2 voordat je argv[2] gebruikt.

Een lus die gebruikersargumenten afdrukt, kan for (int i = 1; i < argc; i++) puts(argv[i]); gebruiken. Om in plaats daarvan vanaf argv + 1 tot een nulpointer te lopen, controleer je eerst argc > 0; als argc nul is, is er geen bereik met gebruikersargumenten dat je zo kunt beginnen. Argumentstrings zijn wijzigbaar, anders dan stringliterals.

Volg volledige rijen

int grid[3][4] bevat twaalf gehele getallen in rijgewijze opslagvolgorde: eerst heel rij 0, dan rij 1 en dan rij 2. Bij int-waarden van 4 bytes neemt elke rij 16 bytes in. grid[2][1] ligt 36 bytes na grid[0][0]: twee volledige rijen dragen 32 bytes bij en de kolom 4.

grid + 1 schuift één rij op. Een functie die de array ontvangt, kan int g[][4] of int (*g)[4] gebruiken, met een afzonderlijk aantal rijen. Ze kan geen int ** gebruiken: de tabel bevat geen opgeslagen rijpointers om te derefereren. Een expliciete typeconversie kan die ontbrekende pointers niet maken.

Op dezelfde manier bevat char names[3][6] achttien tekenposities in rijen van vaste grootte. const char *names[3] bevat drie pointerposities die naar strings van verschillende lengten kunnen verwijzen.

Een functiepointer slaat een verwijzing op naar een functie die later kan worden aangeroepen. Het type omvat het retourtype en de parametertypen. Die typen moeten passen bij de functie die via de pointer wordt gebruikt.

Zet haakjes om de pointernaam

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }

int (*op)(int, int) = add;

Lees vanaf op: het is een pointer, datgene waarnaar wordt gewezen is een functie die twee int-waarden ontvangt, en die functie geeft een int terug. Zonder de haakjes declareert int *op(int, int); een functie die een pointer naar een geheel getal teruggeeft. De haakjes veranderen de betekenis van de declaratie.

Een functienaam wordt in deze initialisator geconverteerd naar een functiepointer. op = &add; is gelijkwaardig aan op = add;. Zowel op(6, 3) als (*op)(6, 3) roept add aan en geeft 9 terug. Door op = sub; toe te wijzen geeft dezelfde aanroep 3 terug. Aan de aanroepexpressie is niets veranderd, behalve de functie die in de pointer is opgeslagen.

Houd de signatuur compatibel

Een pointer van het type int (*)(int, int) kan niet veilig een functie aanroepen die double ontvangt en teruggeeft. Als je er bijvoorbeeld sqrt aan toewijst, krijg je een melding over incompatibele typen. Een functiepointer expliciet converteren om een melding te onderdrukken maakt een niet-passende aanroep niet geldig; het gedrag is ongedefinieerd.

Standaard-C behandelt objectpointers en functiepointers afzonderlijk. void * is het generieke objectpointertype en geen overdraagbare opslag voor een functiepointer. Functiepointers ondersteunen tests op gelijkheid en ongelijkheid, maar geen pointerrekenen.

Een nulfunctiepointer betekent dat er geen aanroepbare functie is. Als een interface die toestand toestaat, controleer je erop:

if (op != NULL) {
    int result = op(6, 3);
    printf("%d\n", result);
}

Een aanroep via een nulfunctiepointer is ongedefinieerd gedrag.

Geef het type één keer een naam

typedef int (*binop)(int, int);
binop ops[] = {add, sub, mul};

De typedef geeft een pointertype een naam. binop selected = mul; declareert één pointer; binop pick(char symbol); declareert een functie die er één teruggeeft. Zonder de typedef zou die retourdeclaratie int (*pick(char symbol))(int, int); zijn.

Een array van functiepointers is een functiepointertabel. ops[2](6, 3) kiest mul en geeft 18 terug. Controleer voor een selectie-index met teken i de voorwaarde i >= 0 && i < 3 voordat je ops[i] evalueert. Indexeren buiten de tabel is ongeldig, ook als elke opgeslagen functie verder aanroepbaar is.

Lees grotere declaraties van binnen naar buiten

Begin bij de naam en werk haakjes en postfixdelen af voordat je verder naar buiten gaat. In int (*table[3])(int, int) maakt table[3] een array van drie elementen, maakt * van elk element een pointer en maakt (int, int) het doel tot een functie die int teruggeeft.

In char *(*f)(const char *) is f een pointer naar een functie die een const char * ontvangt; die functie geeft een char * terug. Houd de eisen aan de levensduur van de teruggegeven pointer gescheiden van de eisen voor een compatibele aanroep via de functiepointer.

Een callbackfunctie is een functie die aan een andere functie wordt doorgegeven en die deze andere functie als onderdeel van haar werk aanroept. Zo blijft de algemene doorloop- of sorteerbewerking gescheiden van de specifieke handeling of volgorde die je kiest.

Geef een bewerking door zonder die aan te roepen

void twice(int *x) { *x *= 2; }

void for_each(int *a, size_t n, void (*fn)(int *)) {
    for (size_t i = 0; i < n; i++) fn(&a[i]);
}

Voor int v[] = {1, 2, 3}; levert for_each(v, 3, twice); de array {2, 4, 6} op. De functienaam levert een pointer. Als je twice() schrijft, probeer je de functie direct aan te roepen zonder het vereiste argument, in plaats van een bewerking voor latere aanroepen door te geven.

Haal een type terug uit een generieke objectpointer

Een void * kan een objectpointer bevatten en terug converteren naar het oorspronkelijke type. Je kunt die niet derefereren of gebruiken voor pointerrekenen in standaard-C, omdat de pointer geen elementtype geeft. Behoud kwalificaties: gegevens die alleen leesbaar zijn, gaan via const void * en daarna via een geschikte pointer naar een const-gekwalificeerd object.

qsort uit <stdlib.h> ontvangt een basisadres, een aantal elementen, een elementgrootte in bytes en een vergelijkingsfunctie als callback. De callbackfunctie heeft het type int (*)(const void *, const void *). Elk argument wijst naar een arrayelement en het teken van de retourwaarde geeft aan waar het eerste element hoort:

Sorteer gehele getallen zonder overloop

int cmp_int(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    return (x > y) - (x < y);
}

/* In the caller: */
int v[] = {42, -7, 19, 0, 3};
qsort(v, 5, sizeof v[0], cmp_int);

De array wordt {-7, 0, 3, 19, 42}. Vergelijkingen leveren 0 of 1 op, dus de retour-expressie levert alleen -1, 0 of 1 op. Als je de volgorde-expressie omkeert naar (y > x) - (y < x), wordt aflopend gesorteerd.

Gebruik return x - y; niet voor willekeurige gehele getallen met teken. Voor een 32-bits int overschrijdt het aftrekken van -2000000000 van 2000000000 de waarde van INT_MAX. Overloop bij gehele getallen met teken is ongedefinieerd gedrag, dus een teruggelopen resultaat of betrouwbaar vergelijkingsteken is niet gegarandeerd.

Sorteer pointers naar strings

int cmp_str(const void *a, const void *b) {
    return strcmp(*(const char *const *)a,
                  *(const char *const *)b);
}

const char *names[] = {"Lin", "Ada", "Grace"};
qsort(names, 3, sizeof names[0], cmp_str);

Neem <string.h> op voor strcmp. Een arrayelement is hier zelf een pointer. De callbackfunctie ontvangt een adres van dat pointerelement, dus door één keer te derefereren haal je het stringadres op. De toegevoegde binnenste const voorkomt dat je het element via deze toegang wijzigt. Na het sorteren is de volgorde "Ada", "Grace", "Lin".

strcmp(a, b) zou de bytes van de pointerposities als tekst lezen. Gebruik ook sizeof names[0], de grootte van een pointerelement, niet sizeof(char) of de lengte van een naam.

Vergelijkingsfuncties moeten elementen ongewijzigd laten en consistent antwoorden, ook wat betreft transitieve ordening. qsort belooft niet de volgorde te behouden van elementen die als gelijk worden vergeleken. bsearch accepteert dezelfde vorm van vergelijkingsfunctie om een array te doorzoeken die al volgens die volgorde is gesorteerd.