Aritmética de punteros: offset, add, wrapping y la procedencia

Un puntero crudo cobra su verdadero poder cuando se mueve. Recorrer un array, saltar al siguiente nodo de una lista, indexar un buffer: todo es aritmética de punteros, sumar y restar posiciones a una dirección. Rust ofrece esa aritmética con una precisión quirúrgica que C nunca tuvo. add y offset se miden en elementos, no en bytes; tienen precondiciones que convierten un simple cálculo —sin dereferenciar nada— en comportamiento indefinido si te sales de la asignación; y wrapping_add ofrece la versión sin esas ataduras para los casos raros donde la necesitas. Pero por debajo de toda la aritmética late una idea que distingue a Rust de la mentalidad “un puntero es solo un número”: la procedencia. Un puntero recuerda de qué asignación nació, y ese recuerdo, no la dirección numérica, es lo que decide qué accesos son legales.

Moverse por la memoria: offset, add, sub

Las operaciones fundamentales desplazan el puntero un número de elementos. add(n) avanza n posiciones —internamente, n * size_of::<T>() bytes—; sub(n) retrocede; offset(delta) acepta un isize con signo. Existen las gemelas byte_add, byte_sub y byte_offset cuando de verdad quieres razonar en bytes.

let v = [10_i32, 20, 30, 40];
let base: *const i32 = v.as_ptr();
unsafe {
    let tercero = base.add(2);          // avanza 2 elementos = 8 bytes
    assert_eq!(*tercero, 30);

    let fin = base.add(4);              // uno-mas-alla del final: legal formarlo
    // let _ = *fin;                     // pero dereferenciarlo seria UB

    let dist = fin.offset_from(base);   // distancia en elementos
    assert_eq!(dist, 4);
}

Estas operaciones parecen inocentes, pero cargan un contrato severo. Para que add u offset sean legales, el puntero de partida y el de llegada deben caer dentro de —o justo al final de— la misma asignación; el desplazamiento en bytes no puede desbordar un isize; y el cálculo no puede dar la vuelta al espacio de direcciones. Violar cualquiera de estas es comportamiento indefinido en el instante del cálculo, aun si nunca llegas a dereferenciar el resultado. La única concesión es el puntero uno-más-allá-del-final: como en C, formarlo es legal (los bucles lo necesitan como centinela), pero dereferenciarlo no.

Medir y saltar en bytes

A veces el paso natural no es un elemento sino un byte: recorrer una cabecera, alinear a mano, saltar campos de tamaños dispares. Para eso están byte_add, byte_sub y byte_offset, que desplazan en bytes crudos sin multiplicar por size_of::<T>(). Y para la operación inversa —cuántos elementos separan dos punteros— está offset_from, que devuelve un isize con signo.

let v = [10_i32, 20, 30, 40];
let base: *const i32 = v.as_ptr();
unsafe {
    let por_bytes = base.byte_add(8);        // 8 bytes = 2 elementos i32
    assert_eq!(*por_bytes, 30);
    let d = por_bytes.offset_from(base);      // resultado en elementos, no en bytes
    assert_eq!(d, 2);
}

offset_from carga sus propias precondiciones: ambos punteros deben pertenecer a la misma asignación, y la resta de direcciones se divide por size_of::<T>(), de modo que para un tipo de tamaño cero la operación carece de sentido y entra en pánico. La regla general se mantiene inquebrantable: la aritmética expresa una intención sobre una asignación concreta, y salirte de ella —midiendo o saltando— rompe el contrato.

wrapping: aritmética sin la promesa de límites

wrapping_add, wrapping_sub y wrapping_offset hacen la misma aritmética pero con envoltura de complemento a dos y sin la precondición de permanecer en la asignación. Calcular con ellas nunca es UB por sí mismo; lo que sigue siendo UB es dereferenciar un puntero que acabe fuera de una asignación viva. Son la herramienta para centinelas que pueden pasarse del final, punteros etiquetados, o algoritmos que comparan direcciones sin tocarlas.

let datos = [0_u8; 4];
let base: *const u8 = datos.as_ptr();

let lejano = base.wrapping_add(usize::MAX);  // calcular esto: legal, no es UB
// let _ = *lejano;                           // dereferenciarlo: eso si seria UB

// util para recorrer hacia atras sin UB al pasarse del inicio
let mut p = base.wrapping_add(4);
while p != base {
    p = p.wrapping_sub(1);
    unsafe { let _ = *p; }   // aqui p si esta siempre dentro
}

La diferencia con add no es cosmética: add promete al optimizador que no te sales, y esa promesa se traduce en código más agresivo; wrapping_add no promete nada sobre límites, solo sobre la aritmética modular. Elige add por defecto —es la que expresa la intención correcta y habilita mejores optimizaciones— y reserva wrapping_* para cuando de verdad necesitas calcular una dirección que podría salirse.

Procedencia: un puntero no es solo un número

Aquí está la idea que separa a Rust del folclore de C. En el modelo abstracto de Rust, un puntero no es su dirección: es una dirección más una procedencia, una etiqueta invisible que dice de qué asignación deriva y, por tanto, a qué memoria tiene permiso de acceder. Toda la aritmética de punteros preserva la procedencia: base.add(2) sigue perteneciendo a la asignación de base, aunque numéricamente aterrice donde tú quieras. No puedes fabricar acceso a la asignación B a partir de un puntero cuya procedencia es la asignación A, aunque la aritmética coincida byte a byte con una dirección de B.

let a = [1_u8; 4];
let b = [2_u8; 4];
let pa: *const u8 = a.as_ptr();
// Aunque calcules la direccion numerica de b partiendo de pa,
// el puntero resultante conserva la procedencia de a: leer b por ahi es UB.
let _ = pa.wrapping_add(b.as_ptr() as usize - pa as usize);

Este modelo, formalizado por los trabajos de Stacked Borrows y Tree Borrows y comprobado por Miri, explica por qué convertir un puntero a usize y de vuelta no es una operación neutra: el entero olvida la procedencia. Por eso Rust 2024 estabiliza las APIs de procedencia estricta —addr para leer solo la dirección, with_addr para transplantar una dirección conservando la procedencia de otro puntero, map_addr para transformarla— que hacen explícito lo que el casteo con as deja implícito. En cuanto al aliasing, los punteros crudos entre sí no imponen ninguna regla: puedes tener mil *mut T al mismo sitio sin pecado. Las reglas de exclusividad muerden solo cuando, a partir de esos punteros, materializas una & o una &mut.

flowchart TD
P[Puntero crudo] --> D[Direccion numerica]
P --> Q[Procedencia asignacion de origen]
D --> N[as usize olvida la procedencia]
Q --> K[add y offset la preservan]
K --> L[Solo accede a la asignacion de origen]
N --> M[El entero es solo un numero sin permisos]
style P fill:#89b4fa,color:#11111b
style Q fill:#a6e3a1,color:#11111b
style D fill:#f9e2af,color:#11111b
style M fill:#f38ba8,color:#11111b