Weak de T: referencias débiles para romper ciclos

El conteo de referencias es local y elegante, pero tiene un punto ciego fatal: los ciclos. Si A posee un Rc hacia B y B posee un Rc hacia A, cada uno mantiene vivo al otro; sus contadores nunca bajan a cero, sus destructores nunca corren y la memoria se fuga —sin que el borrow checker diga una palabra, porque no hay nada inseguro, solo algo que no muere—. Weak<T> es el antídoto: una referencia no poseedora que no incrementa el contador fuerte y, por tanto, no impide que el dato muera. A cambio, no puedes usarla directamente: debes ascenderla a un Rc con upgrade, operación que puede devolver None si el valor ya se fue. Así se modelan los punteros hacia atrás sin crear ciclos.

El ciclo que nunca muere

Construyamos dos nodos que se apunten mutuamente. Necesitamos RefCell para poder enlazarlos después de crearlos (mutabilidad interior):

use std::rc::Rc;
use std::cell::RefCell;

struct Nodo {
    valor: i32,
    enlace: RefCell<Option<Rc<Nodo>>>,
}

fn main() {
    let a = Rc::new(Nodo { valor: 1, enlace: RefCell::new(None) });
    let b = Rc::new(Nodo { valor: 2, enlace: RefCell::new(None) });

    *a.enlace.borrow_mut() = Some(Rc::clone(&b));  // a -> b
    *b.enlace.borrow_mut() = Some(Rc::clone(&a));  // b -> a, el ciclo

    println!("cuenta de a = {}", Rc::strong_count(&a)); // 2
    println!("cuenta de b = {}", Rc::strong_count(&b)); // 2
} // a y b salen de scope: cada cuenta baja de 2 a 1, nunca a 0. Fuga.

Al final del main, el Drop de la variable a baja su cuenta de 2 a 1 —pero b todavía sostiene la otra participación—, y lo mismo con b. Ambos se quedan en 1, ninguno llega a cero, ningún destructor corre: los dos nodos quedan varados en el heap hasta que el proceso muere.

flowchart LR
a[Nodo a cuenta 2] -->|Rc fuerte| b[Nodo b cuenta 2]
b -->|Rc fuerte| a
style a fill:#f38ba8,color:#11111b
style b fill:#f38ba8,color:#11111b

Weak: una referencia que no cuenta

Cada Rc mantiene, en realidad, dos contadores: el fuerte y el débil. Solo el fuerte decide si el valor sigue vivo. Rc::downgrade(&rc) produce un Weak<T> incrementando el contador débil, nunca el fuerte. Un Weak no posee el dato: el valor puede destruirse mientras aún existan Weak apuntándolo, y esos débiles simplemente pasan a no apuntar a nada. (La asignación no se recicla del todo hasta que también los débiles desaparecen, pero el valor T en sí ya se ha destruido.)

upgrade: pedir acceso, que puede fallar

Como el valor puede haberse ido, no puedes desreferenciar un Weak sin más. Weak::upgrade devuelve Option<Rc<T>>: Some —incrementando temporalmente la cuenta fuerte— si el valor sigue vivo, y None si ya fue destruido. Esa firma es la clave de la seguridad: te obliga a reconocer, en cada acceso, que aquello a lo que apuntas quizá ya no exista.

use std::rc::Rc;

fn main() {
    let fuerte = Rc::new(42);
    let debil = Rc::downgrade(&fuerte);

    println!("{:?}", debil.upgrade());  // Some(42): el valor vive
    drop(fuerte);                       // cae el ultimo dueno fuerte
    println!("{:?}", debil.upgrade());  // None: el valor ya no existe
}

Donde en C un puntero hacia atrás que sobrevive a su objetivo es un puntero colgante —y su uso, comportamiento indefinido—, en Rust Weak::upgrade convierte esa catástrofe en un Option que estás forzado a manejar.

El patrón padre-hijo

El caso real donde todo esto encaja es un árbol en el que cada hijo conoce a su padre. Si ambas direcciones fueran Rc, cada pareja padre-hijo sería un ciclo y el árbol entero se fugaría. La solución codifica la dirección de la propiedad en el tipo: el padre posee a los hijos con Rc (fuerte, hacia abajo); el hijo referencia al padre con Weak (débil, hacia arriba). El árbol mantiene vivos a sus descendientes; el puntero hacia atrás no mantiene vivo al ancestro.

use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Nodo {
    valor: i32,
    padre: RefCell<Weak<Nodo>>,        // hacia arriba: debil, no cuenta
    hijos: RefCell<Vec<Rc<Nodo>>>,     // hacia abajo: fuerte, posee
}

fn main() {
    let hoja = Rc::new(Nodo {
        valor: 3,
        padre: RefCell::new(Weak::new()),
        hijos: RefCell::new(vec![]),
    });
    let rama = Rc::new(Nodo {
        valor: 5,
        padre: RefCell::new(Weak::new()),
        hijos: RefCell::new(vec![Rc::clone(&hoja)]),
    });
    *hoja.padre.borrow_mut() = Rc::downgrade(&rama);  // enlace debil hacia el padre

    // subir de la hoja al padre, reconociendo que podria no existir:
    if let Some(p) = hoja.padre.borrow().upgrade() {
        println!("el padre de la hoja vale {}", p.valor);   // 5
    }
}

Weak::new fabrica un débil vacío que ya devuelve None al ascender: el hueco perfecto para “aún no tengo padre”. Cuando el árbol se destruye, rama cae, su cuenta fuerte llega a cero —la referencia débil desde hoja no la retenía— y todo se libera limpiamente.