CKTIS / C
Aritmética de punteros en C
Desplaza punteros por elementos, usa la posición justo después del final del array y calcula diferencias representables en `ptrdiff_t`.
Versión: ISO C23; implementation support may vary
Sintaxis
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_tEn C, la aritmética de punteros desplaza un puntero p a un tipo de objeto completo en un número entero de elementos, no de bytes. p + n y n + p lo desplazan n posiciones; p - n lo desplaza en sentido contrario. El resultado conserva el tipo de p, y p += n guarda la nueva posición en p. No se pueden sumar dos punteros. La aritmética con void * o punteros a funciones es una extensión de GNU C, no una regla de ISO C23.
El puntero inicial y el resultado deben apuntar cada uno a un elemento del mismo array durante su vida útil o a la posición justo después del último elemento. Esa posición sirve como marca de fin y permite retroceder, pero no se puede desreferenciar. El mero cálculo de una posición anterior al primer elemento o posterior a esa posición límite tiene comportamiento indefinido. Para estos operadores, un objeto que no es un elemento de un array se comporta como un array de un solo elemento.
p - q exige punteros a tipos de objeto completos compatibles, que pueden diferir en sus calificadores. Ambos deben pertenecer al mismo array en el sentido anterior. El resultado es la diferencia de índices en elementos, con signo y de tipo ptrdiff_t, definido en <stddef.h>. Si no es representable, el comportamiento es indefinido. Usa %td en printf. En cambio, con dos operandos aritméticos, + y - operan sobre números con las conversiones aritméticas habituales; el - unario obtiene el opuesto de un número, no de un puntero.
Antes de cur += lf o w += seg, gestiona cualquier resultado de error NULL y comprueba el desplazamiento con respecto al rango restante del array. Que un puntero no sea nulo no garantiza ni su validez ni el respeto de los límites. Para calcular un tamaño en bytes, comprueba count <= SIZE_MAX / sizeof *p antes de multiplicar, con count de tipo size_t y SIZE_MAX definido en <stdint.h>. Esta comprobación no verifica los límites del array ni que cur - r quepa en ptrdiff_t.
Ejemplos
#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;
}
Resultado
30 2 4 -4 40
`cur` apunta a `30` y `w` está justo después del array. `cur - r`, `w - r` y `r - w` dan `2`, `4` y `-4`, respectivamente. `*(w - 1)` lee `40` sin desreferenciar `w`.
Lecciones relacionadas
- C · Lección 81 · Avanzado · Versión: 3