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('<', "<"))
} 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
- Implementa una pila enlazada simple:
struct Stack<T> { head: Option<Box<Node<T>>> }conpush,popypeek. Pista:self.head.take(). - Usa
Rc<RefCell<Vec<String>>>para construir un registro de mensajes compartido por dos structs que añaden mensajes cada uno. - Crea a propósito un ciclo de referencias con
Rc<RefCell<Option<Rc<…>>>>, añade una implementación deDropque 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.¿Por qué no compila
enum List { Cons(i32, List), Nil }?2.¿Qué ocurre al llamar a
borrow_mut()sobre unRefCellque ya está prestado?3.¿Cómo evitas una fuga de memoria cuando dos valores
Rcnecesitan referirse el uno al otro?