Crear y dereferenciar: de la referencia al puntero y de vuelta

Un puntero crudo casi nunca nace de la nada: nace de un valor que ya posees. El camino habitual es partir de una referencia —&x as *const T— y dejar que decaiga a puntero. Pero ese camino esconde una sutileza que el nivel entero gira en torno a ella: escribir &x afirma que x es un lugar válido, alineado e inicializado, y hay situaciones —memoria sin inicializar, un campo desalineado de un struct empaquetado— donde esa afirmación es falsa y forjar la referencia intermedia es, en sí mismo, comportamiento indefinido. Por eso Rust 2024 promueve un operador que toma la dirección sin pasar por una referencia: &raw const y &raw mut. Dominar cuándo cada uno, y cómo leer y escribir a través del resultado, es aprender a hablar de un sitio en memoria sin prometer nada sobre lo que vive en él.

De una referencia a un puntero

La vía clásica aprovecha que una referencia decae a puntero por coerción. Puedes ser explícito con as o dejar que el tipo de destino guíe la conversión.

let x = 10_i32;
let p: *const i32 = &x;          // coercion implicita
let p2 = &x as *const i32;       // conversion explicita
let mut y = 20_i32;
let pm = &mut y as *mut i32;     // desde una referencia mutable

El problema aparece cuando el lugar cuya dirección quieres no es una referencia válida. Escribir &s.campo construye una & a ese campo, y para que esa referencia exista el campo debe estar alineado e inicializado. En un struct con #[repr(packed)] los campos pierden su alineación natural, así que tomar una referencia a uno es directamente un error de compilación o UB latente. Aquí entra el operador de referencia cruda, &raw, que produce el puntero sin materializar la referencia intermedia:

#[repr(packed)]
struct Paquete { bandera: u8, valor: u32 }

let s = Paquete { bandera: 1, valor: 7 };
// let r = &s.valor;             // ERROR: campo potencialmente desalineado
let p = &raw const s.valor;      // OK: puntero crudo, no exige alineacion
let v = unsafe { p.read_unaligned() };
assert_eq!(v, 7);

&raw const lugar da un *const T; &raw mut lugar da un *mut T. Son la sintaxis estabilizada que sustituye a las viejas macros addr_of! y addr_of_mut!, y en la edición 2024 son la forma canónica de tomar la dirección de algo que quizá no puedas —o no quieras— prometer válido todavía: campos empaquetados, memoria sin inicializar, o un static mut cuyo acceso por referencia la edición 2024 restringe con dureza.

Leer y escribir a través del puntero

Con un puntero en mano, la lectura y la escritura viven dentro de unsafe. El operador * es la vía directa; read y write son las variantes por método, con semántica de movimiento y sin ejecutar el Drop del valor previo.

let mut n = 0_i32;
let p: *mut i32 = &raw mut n;
unsafe {
    *p = 99;              // escritura directa
    let leido = *p;       // lectura directa
    assert_eq!(leido, 99);

    p.write(123);         // mueve 123 al destino, sin dropear lo anterior
    let x = p.read();     // copia bit a bit el valor, sin dropear el origen
    assert_eq!(x, 123);
}

La distinción entre *p = v y p.write(v) es fina pero real: la asignación con * dropea el valor que había en el destino antes de poner el nuevo, mientras que write lo sobrescribe crudo, ideal cuando el destino aún no contiene un valor legítimo que dropear. Para memoria desalineada existen read_unaligned y write_unaligned; para registros de hardware que no deben optimizarse ni reordenarse, read_volatile y write_volatile. Cada *p que ejecutes debe cumplir, sin excepción, cinco condiciones.

Para mover bloques enteros —no un valor sino muchos de golpe— están ptr::copy (permite solapamiento, como memmove) y ptr::copy_nonoverlapping (regiones disjuntas, como memcpy). Son el motor de todo desplazamiento masivo de memoria: insertar en mitad de un Vec, compactar un buffer, realojar los elementos cuando la colección crece.

let origen = [1_u8, 2, 3, 4];
let mut destino = [0_u8; 4];
unsafe {
    std::ptr::copy_nonoverlapping(origen.as_ptr(), destino.as_mut_ptr(), 4);
}
assert_eq!(destino, [1, 2, 3, 4]);

Memoria sin inicializar: MaybeUninit

El caso límite es escribir donde todavía no hay nada. No puedes leer memoria sin inicializar ni siquiera para copiarla, y no puedes tomar una &mut a ella porque afirmaría un valor válido inexistente. La herramienta correcta es MaybeUninit<T>: una caja del tamaño de T que el compilador sabe que puede contener basura, de la que obtienes un *mut T para escribir, y que solo declaras inicializada con assume_init cuando tú sabes que ya lo está.

use std::mem::MaybeUninit;

let mut hueco = MaybeUninit::<i32>::uninit();
let p = hueco.as_mut_ptr();          // *mut i32 a memoria sin inicializar
unsafe {
    p.write(7);                       // inicializa sin leer basura previa
    let listo = hueco.assume_init();  // ahora si es un i32 valido
    assert_eq!(listo, 7);
}

Fíjate en la coreografía: as_mut_ptr da el puntero, write (no *p =, que intentaría dropear la basura previa) lo inicializa, y solo entonces assume_init promete que el contenido es un T legítimo. Este patrón es el latido de todo constructor de estructura de datos que reserva capacidad antes de rellenarla.

flowchart TD
L[Un lugar en memoria] --> V[El lugar es valido vivo y alineado]
V -->|Si| A[Usa ref x as const T]
V -->|No| B[Usa raw const x o raw mut x]
A --> D[Puntero crudo]
B --> D
D --> W[Escribir con write o asterisco dentro de unsafe]
D --> R[Leer con read o asterisco dentro de unsafe]
style A fill:#a6e3a1,color:#11111b
style B fill:#f9e2af,color:#11111b
style D fill:#89b4fa,color:#11111b
style W fill:#cba6f7,color:#11111b
style R fill:#cba6f7,color:#11111b