Aprender Rust Smart Pointers

Módulo del curso de Rust

Rust
Rust
Módulo del curso
Actualizado: 18/04/2026

Módulo: Smart Pointers

Este módulo forma parte del curso de Rust. .

Los smart pointers (punteros inteligentes) son estructuras de datos que actúan como punteros pero con funcionalidad adicional: controlan la gestión de memoria, implementan semánticas de ownership especiales o permiten patrones que las referencias ordinarias no admiten. Implementan los traits Deref (para usarlos como referencias) y Drop (para liberar recursos al salir del scope).

Box<T>: asignación en el heap

Box<T> es el smart pointer más simple. Almacena un valor en el heap y resulta esencial para tipos de tamaño desconocido en compilación (como listas enlazadas recursivas) y para objetos trait con dynamic dispatch (Box<dyn Trait>).

Rc<T>: múltiples propietarios en un hilo

Rc<T> (Reference Counting) permite que varios propietarios compartan un mismo valor en un único hilo. Mantiene un contador de referencias y libera la memoria cuando el contador llega a cero. Rc::clone no copia el dato sino que incrementa el contador.

Arc<T>: Rc thread-safe

Arc<T> (Atomic Reference Counting) es la versión thread-safe de Rc<T>. Usa operaciones atómicas para el contador, por lo que puede compartirse entre hilos. Se usa habitualmente junto con Mutex<T> para acceso mutable thread-safe.

RefCell<T>: mutabilidad interior

RefCell<T> permite mutabilidad interior: aunque el RefCell en sí sea inmutable, se puede mutar el valor que contiene. Las reglas de borrowing se verifican en tiempo de ejecución (no en compilación), provocando un panic si se violan. El patrón Rc<RefCell<T>> es habitual para múltiples propietarios con capacidad de mutación.

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

let lista = Rc::new(RefCell::new(vec![1, 2, 3]));
let clon = Rc::clone(&lista);
clon.borrow_mut().push(4);  // Mutamos a través del clon
println!("{:?}", lista.borrow()); // [1, 2, 3, 4]

Weak<T>: evitar ciclos de referencia

Weak<T> es una referencia débil que no incrementa el contador fuerte de Rc. Se usa para romper ciclos de referencia (por ejemplo, relaciones padre-hijo bidireccionales) que de otro modo impedirían que la memoria se liberara.

Explora más sobre Rust

Descubre más recursos de Rust

Alan Sastre - Autor del curso

Alan Sastre

Ingeniero de Software y formador, CEO en CertiDevs

Ingeniero de software especializado en Full Stack y en Inteligencia Artificial. Como CEO de CertiDevs, Rust es una de sus áreas de expertise. Con más de 15 años programando, 6K seguidores en LinkedIn y experiencia como formador, Alan se dedica a crear contenido educativo de calidad para desarrolladores de todos los niveles.