FerrousPath

Nivel 2 · Practicante· Lección 5 de 8 · 30 min

Punteros inteligentes y mutabilidad interior

Box, Rc, RefCell, Weak y Cow — reserva en el heap, propiedad compartida y mutación detrás de una referencia compartida.

Un puntero inteligente (smart pointer) es un tipo que es dueño de unos datos y se comporta como un puntero hacia ellos mediante el trait Deref. String y Vec son punteros inteligentes. Esta lección trata los que eliges explícitamente.

Box<T>: un dueño, en el heap

#[derive(Debug)]
enum Expr {
    Num(f64),
    Add(Box<Expr>, Box<Expr>),
    Mul(Box<Expr>, Box<Expr>),
    Neg(Box<Expr>),
}

fn eval(e: &Expr) -> f64 {
    match e {
        Expr::Num(n) => *n,
        Expr::Add(a, b) => eval(a) + eval(b),
        Expr::Mul(a, b) => eval(a) * eval(b),
        Expr::Neg(a) => -eval(a),
    }
}

fn main() {
    // (2 + 3) * -4
    let e = Expr::Mul(
        Box::new(Expr::Add(Box::new(Expr::Num(2.0)), Box::new(Expr::Num(3.0)))),
        Box::new(Expr::Neg(Box::new(Expr::Num(4.0)))),
    );
    println!("{}", eval(&e));
}

Usa Box para tipos recursivos (que de otro modo tendrían tamaño infinito), para valores grandes que quieres mover de forma barata y para trait objects (Box<dyn Trait>). Un Box es exactamente un puntero y libera su contenido cuando se libera él.

eval(a) funciona aunque a sea un &Box<Expr>: la coerción por deref (deref coercion) convierte &Box<Expr> en &Expr automáticamente. El mismo mecanismo convierte &String en &str.

Rc<T>: propiedad compartida

A veces un valor no tiene un único dueño evidente: un nodo referenciado desde varios lugares de un grafo, por ejemplo. Rc<T> (reference counted, con conteo de referencias) mantiene vivo el valor hasta que se libera el último Rc que apunta a él.

use std::rc::Rc;

fn main() {
    let shared = Rc::new(String::from("shared config"));
    let a = Rc::clone(&shared); // incrementa el contador; no copia la cadena
    let b = Rc::clone(&shared);
    println!("count = {}", Rc::strong_count(&shared));
    drop(a);
    println!("count = {}", Rc::strong_count(&shared));
    println!("{b}");
}

Rc<T> solo te da acceso compartido a su contenido: hay muchos dueños, así que no hay &mut. Además es para un solo hilo; la versión segura entre hilos es Arc<T>, en el nivel 3.

RefCell<T>: mutabilidad interior

Las reglas de préstamo se comprueban en tiempo de compilación, y la comprobación es conservadora. RefCell<T> traslada esa misma comprobación al tiempo de ejecución: puedes obtener un préstamo mutable a través de una referencia compartida, y si rompes la regla el programa entra en pánico en lugar de no compilar.

use std::cell::RefCell;

fn main() {
    let cell = RefCell::new(vec![1, 2, 3]);

    cell.borrow_mut().push(4);          // préstamo mutable, liberado en el punto y coma
    println!("{:?}", cell.borrow());

    let reading = cell.borrow();
    let result = cell.try_borrow_mut(); // ya está prestado: esto falla
    println!("second borrow ok? {}", result.is_ok());
    drop(reading);
}

Cell<T> es el pariente más ligero para tipos Copy: get y set, sin préstamos ni pánicos.

Rc<RefCell<T>>: compartido y mutable

Combinar los dos da varios dueños que pueden modificar todos el valor, a costa de comprobaciones en tiempo de ejecución y de perder las garantías en tiempo de compilación.

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

#[derive(Debug)]
struct Account {
    balance: i64,
}

fn main() {
    let account = Rc::new(RefCell::new(Account { balance: 100 }));
    let cashier = Rc::clone(&account);
    let auditor = Rc::clone(&account);

    cashier.borrow_mut().balance -= 30;
    println!("auditor sees {}", auditor.borrow().balance);
}

Recurre a esto en último lugar, no en primero. A menudo un índice dentro de un Vec o un árbol de propiedad reestructurado es más simple y más rápido.

Weak<T>: romper ciclos

Dos Rc que se apuntan mutuamente nunca llegan a un contador de cero y, por tanto, nunca se liberan. Weak<T> es una referencia que no posee el valor y que hay que promover (upgrade) antes de usarla:

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

struct Node {
    name: String,
    parent: RefCell<Weak<Node>>,
    children: RefCell<Vec<Rc<Node>>>,
}

fn main() {
    let root = Rc::new(Node {
        name: "root".into(),
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });
    let leaf = Rc::new(Node {
        name: "leaf".into(),
        parent: RefCell::new(Rc::downgrade(&root)),
        children: RefCell::new(vec![]),
    });
    root.children.borrow_mut().push(Rc::clone(&leaf));

    let parent = leaf.parent.borrow().upgrade(); // Option<Rc<Node>>
    println!("{}'s parent: {:?}", leaf.name, parent.map(|p| p.name.clone()));
    println!("root: strong={} weak={}", Rc::strong_count(&root), Rc::weak_count(&root));
}

Los padres son dueños de los hijos (referencia fuerte); los hijos se refieren a los padres (referencia débil).

Cow<T>: clonar al escribir

Cow contiene o bien un préstamo o bien un valor con dueño, y solo reserva memoria si tiene que cambiar los datos.

use std::borrow::Cow;

fn escape(input: &str) -> Cow<'_, str> {
    if input.contains('<') {
        Cow::Owned(input.replace('<', "&lt;"))
    } else {
        Cow::Borrowed(input) // caso habitual: sin reserva de memoria
    }
}

fn main() {
    for s in ["plain text", "a < b"] {
        let out = escape(s);
        let kind = if matches!(out, Cow::Borrowed(_)) { "borrowed" } else { "owned" };
        println!("{out} ({kind})");
    }
}

Cómo elegir

Necesidad Usa
Un dueño, reserva en el heap Box<T>
Varios dueños, solo lectura, un hilo Rc<T>
Varios dueños, con mutación, un hilo Rc<RefCell<T>>
Varios dueños entre hilos Arc<T>, Arc<Mutex<T>>
Una referencia que no mantiene vivo el valor Weak<T>
Quizá prestado, quizá con dueño Cow<'a, T>

Ejercicios

  1. Implementa una pila enlazada simple: struct Stack<T> { head: Option<Box<Node<T>>> } con push, pop y peek. Pista: self.head.take().
  2. Usa Rc<RefCell<Vec<String>>> para construir un registro de mensajes compartido por dos structs que añaden mensajes cada uno.
  3. Crea a propósito un ciclo de referencias con Rc<RefCell<Option<Rc<…>>>>, añade una implementación de Drop que imprima y confirma que nunca se ejecuta.
Solución del 1
struct Node<T> { value: T, next: Option<Box<Node<T>>> }
struct Stack<T> { head: Option<Box<Node<T>>> }

impl<T> Stack<T> {
    fn new() -> Self { Stack { head: None } }
    fn push(&mut self, value: T) {
        let next = self.head.take();
        self.head = Some(Box::new(Node { value, next }));
    }
    fn pop(&mut self) -> Option<T> {
        self.head.take().map(|node| {
            self.head = node.next;
            node.value
        })
    }
    fn peek(&self) -> Option<&T> {
        self.head.as_ref().map(|n| &n.value)
    }
}

fn main() {
    let mut s = Stack::new();
    s.push(1); s.push(2);
    println!("{:?}", s.peek());
    println!("{:?} {:?} {:?}", s.pop(), s.pop(), s.pop());
}

Option::take sustituye el valor por None y te entrega el anterior: el truco clave para mover algo fuera de un campo de un &mut.

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Por qué no compila enum List { Cons(i32, List), Nil }?

  2. 2.¿Qué ocurre al llamar a borrow_mut() sobre un RefCell que ya está prestado?

  3. 3.¿Cómo evitas una fuga de memoria cuando dos valores Rc necesitan referirse el uno al otro?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?