*const T y *mut T: los punteros sin promesas

Hasta ahora, todo puntero que has manejado en Rust venía con un guardaespaldas. La referencia &T o &mut T lleva cosida una promesa que el compilador vigila sin descanso: apunta a memoria válida, respeta un lifetime, está alineada y obedece las reglas de aliasing. El puntero crudo es esa misma dirección de memoria despojada de toda promesa. *const T y *mut T son números con un poco de historia —una dirección y su procedencia— y nada más. No garantizan apuntar a algo vivo, ni a algo de tu tipo, ni siquiera a algo. Son la puerta que Rust deja entornada hacia el modelo de memoria plano de la máquina, y cruzarla es el gesto primitivo sobre el que descansa todo lo que la biblioteca estándar hace por debajo.

Una dirección despojada de garantías

Una referencia &T es, en la máquina, exactamente una dirección; pero en el sistema de tipos es una dirección más cuatro promesas que el compilador demuestra por ti: que no es nula, que está alineada, que apunta a un valor inicializado del tipo correcto durante un lifetime concreto, y que respeta el aliasing (una &mut es única; las & comparten sin mutar). El puntero crudo conserva la dirección y tira las cuatro promesas por la ventana.

let x = 42_i32;
let r: &i32 = &x;               // referencia: el compilador vela por ella
let p: *const i32 = &x;         // puntero crudo: coercion desde la referencia

let nulo: *const i32 = std::ptr::null();   // crear un nulo: seguro
let colgante = 0x1234 as *const i32;        // una direccion inventada: seguro

let valor = unsafe { *p };      // dereferenciar: aqui firmas tu el contrato

La asimetría es deliberada y define el nivel entero. Crear un puntero crudo no toca memoria: solo calcula o copia una dirección, y por eso es una operación segura, incluso si el puntero es nulo o disparatado. Dereferenciarlo —leer o escribir en lo que apunta— sí toca memoria, y ahí el compilador se aparta: no tiene forma de demostrar que la dirección es válida, así que te obliga a envolver la operación en unsafe, tu firma jurando que has verificado a mano lo que él ya no puede. Un puntero crudo es además Copy (duplicarlo es copiar una palabra), no arrastra ningún Drop, y —crucialmente— no es Send ni Sync: por eso los tipos que los contienen deben reafirmar esas capacidades a mano.

const frente a mut: intención, no candado

Con las referencias, &T y &mut T son universos separados que el compilador hace cumplir: por una &T jamás escribes, y una &mut T es exclusiva. Con los punteros crudos, la distinción entre *const T y *mut T se degrada a mera documentación de intención. No hay candado: puedes convertir libremente entre ambas con .cast_mut(), .cast_const() o un simple as.

let mut n = 10_i32;
let pc: *const i32 = &n;
let pm: *mut i32 = pc.cast_mut();   // const a mut, sin ceremonia
unsafe { *pm = 20; }                // el tipo lo permite; la validez la juras tu

Que el sistema de tipos lo permita no significa que sea sano. El permiso real para escribir no lo concede el mut del puntero, sino la procedencia: la asignación de la que el puntero deriva. Si pm procede en última instancia de una &i32 compartida o de un static inmutable, escribir a través de él es comportamiento indefinido aunque el compilador te haya dejado teclearlo. El mut del puntero es una sombra difusa de las reglas del borrow checker, no su reencarnación.

Punteros gordos: cuando T no cabe en una palabra

Un puntero crudo a un tipo de tamaño conocido (i32, un struct corriente) es una sola palabra máquina. Pero cuando T no tiene tamaño en compilación —un slice [U] o un objeto de trait dyn Trait— el puntero se vuelve gordo: transporta la dirección y una segunda palabra de metadatos, la longitud para un slice o el puntero a la vtable para un objeto de trait.

use std::mem::size_of;
assert_eq!(size_of::<*const i32>(),  size_of::<usize>());       // fino: 1 palabra
assert_eq!(size_of::<*const [i32]>(), 2 * size_of::<usize>());  // gordo: dato y longitud

let v = [1, 2, 3];
let gordo: *const [i32] = std::ptr::slice_from_raw_parts(v.as_ptr(), 3);
assert_eq!(unsafe { (*gordo).len() }, 3);   // la longitud viaja en el puntero

Esta dualidad importará cuando construyas estructuras de datos: slice_from_raw_parts y su gemela mutable te dejan fabricar la vista gorda desde una dirección fina más una longitud, sin pasar por una referencia.

El nulo, y por qué crear basura es legal

std::ptr::null() y std::ptr::null_mut() fabrican el puntero nulo, y un entero cualquiera casteado con as fabrica un puntero a una dirección arbitraria. Ambas cosas compilan sin unsafe, y esto desconcierta a quien viene creyendo que “puntero peligroso” y “operación peligrosa” son sinónimos.

let nulo: *mut u8 = std::ptr::null_mut();
let inventado = 0xDEAD_BEEF_usize as *const u32;   // legal de construir
assert!(nulo.is_null());
assert!(!inventado.is_null());

No hay peligro en tener una dirección disparatada; el peligro nace al creerla válida y dereferenciarla. Por eso Rust separa con nitidez los dos gestos: construir es un cálculo puro sin consecuencias observables, y solo el acceso —el unsafe— afirma algo sobre el mundo. Guarda esta idea, porque reaparecerá con fuerza: Option<NonNull<T>> aprovecha precisamente la imposibilidad del patrón de bits nulo para representar la ausencia sin gastar ni un byte de más.

flowchart TD
M[Direccion de memoria] --> R[Referencia ref T o ref mut T]
M --> C[Puntero crudo const T o mut T]
R --> RG[El compilador prueba validez lifetime alineacion y aliasing]
C --> CG[Cero garantias solo direccion y procedencia]
RG --> S[Usarla es seguro]
CG --> U[Dereferenciarlo exige unsafe]
style R fill:#a6e3a1,color:#11111b
style C fill:#f38ba8,color:#11111b
style S fill:#89b4fa,color:#11111b
style U fill:#cba6f7,color:#11111b