CKTIS / C
Pointerrekenen in C
Verplaats pointers per element, gebruik de positie direct na het array-einde en bereken verschillen die in `ptrdiff_t` passen.
Versie: ISO C23; implementation support may vary
Syntax
ISO C23 (implementation support may vary):
T *p; // T is a complete object type
p + n; n + p; p - n; // n has integer type; result has p's type
p += n; p -= n; // update a modifiable pointer variable
p - q; // compatible complete pointed-to types, possibly differently qualified; result: ptrdiff_tBij pointerrekenen in C verschuif je een pointer p naar een compleet objecttype met een geheel aantal elementen, niet bytes. p + n en n + p verschuiven hem n posities; p - n verschuift hem in de omgekeerde richting. Het resultaat heeft het type van p; p += n slaat de nieuwe positie op in p. Je kunt geen twee pointers optellen. Rekenen met void * of functiepointers is een uitbreiding van GNU C, geen onderdeel van ISO C23.
De oorspronkelijke pointer en het resultaat moeten elk tijdens de levensduur van dezelfde array naar een element ervan wijzen, of naar de positie direct na het laatste element. Die positie kan als eindmarkering dienen en je kunt van daaruit teruggaan, maar je mag haar niet derefereren. Zelfs het berekenen van een positie vóór het eerste element of voorbij de positie direct na het laatste element leidt tot ongedefinieerd gedrag. Voor deze operatoren gedraagt een object dat geen array-element is zich als een array met één element.
p - q vereist pointers naar compatibele complete objecttypen, waarvan de kwalificaties mogen verschillen. Beide moeten in de bovenstaande zin bij dezelfde array horen. Het resultaat is het indexverschil in elementen, met teken en van het type ptrdiff_t uit <stddef.h>. Past het verschil daar niet in, dan is het gedrag ongedefinieerd. Gebruik %td in printf. Met twee rekenkundige operanden voeren + en - juist numerieke bewerkingen uit met de gebruikelijke rekenkundige conversies; unaire - geeft de tegengestelde waarde van een getal, niet van een pointer.
Handel vóór cur += lf of w += seg een eventuele foutwaarde NULL af en toets de verschuiving aan het resterende arraybereik. Een pointer die niet nul is, bewijst op zichzelf geen geldigheid en zegt niets over de grenzen. Controleer bij een grootte in bytes vóór de vermenigvuldiging count <= SIZE_MAX / sizeof *p, met count van het type size_t en SIZE_MAX uit <stdint.h>. Die controle bewijst niet dat de arraygrenzen worden gerespecteerd of dat cur - r in ptrdiff_t past.
Voorbeelden
#include <stddef.h>
#include <stdio.h>
int main(void)
{
int a[] = {10, 20, 30, 40};
int *r = a;
int *cur = r;
size_t lf = 2;
cur += lf;
int *w = cur;
size_t seg = 2;
w += seg;
printf("%d %td %td %td %d\n", *cur, cur - r, w - r, r - w, *(w - 1));
return 0;
}
Resultaat
30 2 4 -4 40
`cur` wijst naar `30` en `w` wijst naar de positie direct na de array. `cur - r`, `w - r` en `r - w` leveren respectievelijk `2`, `4` en `-4` op. `*(w - 1)` leest `40` zonder `w` te derefereren.
Gerelateerde lessen
- C · Les 81 · Gevorderd · Versie: 3