Aritmética de punteros: sumar en unidades de tipo

La aritmética de punteros es la operación que convierte una dirección aislada en la capacidad de recorrer estructuras enteras. Su regla central desconcierta al principio y es evidente después: sumar 1 no avanza un byte, avanza un elemento. Detrás de esa decisión de diseño hay una idea potente —el puntero mide en unidades de su propio tipo— y un conjunto de reglas estrictas que separan el código correcto del que solo parece funcionar.

Sumar uno avanza un elemento, no un byte

La regla es que la aritmética de punteros se expresa en unidades del tipo apuntado. Si p es un int * y un int ocupa cuatro bytes, entonces p + 1 es la dirección de p más cuatro. El compilador escala automáticamente por sizeof del tipo apuntado.

#include <stdio.h>

int main(void)
{
    int    nums[4] = { 10, 20, 30, 40 };
    int   *pi = nums;
    char  *pc = (char *)nums;

    printf("%p\n", (void *)(pi + 1));  // avanza 4 bytes
    printf("%p\n", (void *)(pc + 1));  // avanza 1 byte
}

Que la escala dependa del tipo no es un capricho: es lo que hace que la indexación de arrays funcione. La expresión nums[i] está definida en el estándar como una abreviatura exacta de *(nums + i), y esa suma solo aterriza en el elemento correcto si se escala por el tamaño del elemento.

De esa definición se sigue una curiosidad que suele citarse como broma y que en realidad es una demostración: como la suma es conmutativa, nums[i] y i[nums] son literalmente la misma expresión para el compilador. No lo escribas nunca en código real, pero entiende lo que revela: los corchetes no son una operación de array, son azúcar sobre aritmética de punteros.

La diferencia de punteros y ptrdiff_t

La resta entre dos punteros al mismo array no da bytes: da cuántos elementos los separan. Es la operación inversa de la suma y respeta la misma escala.

#include <stdio.h>
#include <stddef.h>

int main(void)
{
    double datos[8];
    double *inicio = datos;
    double *fin    = datos + 8;      // uno mas alla del final: legal

    ptrdiff_t n = fin - inicio;      // 8, no 64
    printf("%td elementos\n", n);
}

El tipo del resultado es ptrdiff_t, definido en stddef.h. Es un entero con signo, porque la diferencia puede ser negativa si restas en el otro orden, y se imprime con el especificador %td. Usar int para almacenar una diferencia es un error clásico en cuanto los arrays superan el rango de int.

Hay dos matices que separan al que memoriza del que entiende. El primero: restar punteros que no pertenecen al mismo objeto es comportamiento indefinido, aunque numéricamente el resultado parezca razonable. El segundo: la resta exige que ambos punteros sean del mismo tipo, porque si no la unidad de medida sería ambigua.

Las reglas que hay que respetar

La aritmética de punteros solo está definida dentro de un objeto, y con una única excepción cuidadosamente diseñada. Estas son las fronteras.

La regla del “uno más allá del final” es la más elegante del conjunto, y existe por una razón muy concreta: hace que el idioma de recorrido con condición de parada sea legal. Sin ella, el bucle canónico de C sería comportamiento indefinido en su última iteración.

Merece un apunte la prohibición sobre void *. Como ese tipo no tiene lente, no hay unidad por la que escalar la suma, así que la aritmética sobre él no está definida en C estándar. GCC y Clang la admiten como extensión tratándolo como si fuera char *, y ese es exactamente el problema: compila sin queja, se cuela en el código y deja de compilar en cuanto activas -pedantic o cambias de compilador. La forma portable es convertir explícitamente antes de operar.

void *base = obtener_buffer();

// unsigned char *p = base + 16;   // extension, no C estandar
unsigned char *p = (unsigned char *)base + 16;   // portable y explicito

flowchart LR
E0[Elemento 0] --> E1[Elemento 1] --> E2[Elemento 2] --> E3[Elemento 3]
E3 --> FIN[Uno mas alla: formar y comparar si, desreferenciar no]
FIN --> MAL[Dos mas alla: comportamiento indefinido al formarlo]
style FIN fill:#f9e2af,color:#11111b
style MAL fill:#f38ba8,color:#11111b

Recorrer con punteros frente a índices

Con las reglas claras, el recorrido idiomático de C se lee solo. Compara las dos formas de sumar un array:

#include <stddef.h>

// Version con indices: clara y perfectamente idiomatica.
long suma_indices(const int *v, size_t n)
{
    long total = 0;
    for (size_t i = 0; i < n; i++)
        total += v[i];
    return total;
}

// Version con punteros: la condicion usa el puntero uno mas alla.
long suma_punteros(const int *v, size_t n)
{
    long total = 0;
    for (const int *p = v; p != v + n; p++)
        total += *p;
    return total;
}

Nótese que el bucle con punteros forma v + n y lo compara, pero nunca lo desreferencia: exactamente lo que la regla permite. Obsérvese también que la condición usa != y no <. Con arrays contiguos ambas funcionan, pero la desigualdad es la forma canónica porque solo exige que los punteros sean comparables por igualdad, no que exista un orden entre ellos. Es el mismo criterio que hace que los iteradores de otros lenguajes se comparen así, y no es casualidad: heredaron el idioma de aquí. Sobre rendimiento conviene bajar las expectativas: con optimizaciones activadas ambos suelen generar el mismo código máquina. La razón para dominar la forma con punteros no es la velocidad, sino que es la única disponible cuando recorres estructuras que no son arrays contiguos y que es el vocabulario con el que está escrita la biblioteca estándar.