{"id":29467,"date":"2024-09-03T15:15:26","date_gmt":"2024-09-03T13:15:26","guid":{"rendered":"https:\/\/www.codemotion.com\/magazine\/?p=29467"},"modified":"2024-09-03T15:15:28","modified_gmt":"2024-09-03T13:15:28","slug":"navegando-por-los-smart-pointers-en-rust","status":"publish","type":"post","link":"https:\/\/www.codemotion.com\/magazine\/es\/lenguajes-de-programacion\/navegando-por-los-smart-pointers-en-rust\/","title":{"rendered":"Navegando por los Smart Pointers en Rust"},"content":{"rendered":"\n

En mi art\u00edculo anterior sobre Ownership<\/a>, exploramos c\u00f3mo Rust maneja la propiedad de los datos de manera segura, permiti\u00e9ndonos evitar muchos de los errores comunes relacionados con la memoria en otros lenguajes. Este es el pilar fundamental que hace que Rust sea tan poderoso. Ahora, es momento de profundizar en un concepto relacionado: los smart pointers<\/em>.<\/p>\n\n\n\n

Si bien los lifetimes<\/em>, de los que habl\u00e9 en un art\u00edculo relacionado que pronto estar\u00e1 disponible en el blog de LeanMind<\/a>, juegan un rol crucial en la gesti\u00f3n de las referencias y su validez, los smart pointers<\/em> nos proporcionan una manera a\u00fan m\u00e1s avanzada de manejar la memoria y otros recursos en Rust.<\/p>\n\n\n\n

\u00bfQu\u00e9 son los Smart Pointers?<\/h2>\n\n\n\n

Un smart pointer<\/em> es un tipo de dato que no solo contiene una direcci\u00f3n de memoria (como un puntero tradicional), sino que tambi\u00e9n tiene capacidades adicionales que permiten gestionar autom\u00e1ticamente la memoria y otros recursos. A diferencia de las referencias regulares (&T<\/code> y &mut T<\/code>), los smart pointers<\/em> implementan el trait Deref<\/code> y, en muchos casos, el trait Drop<\/code>. Esto les da la capacidad de comportarse como punteros mientras administran la memoria o recursos de manera m\u00e1s inteligente.<\/p>\n\n\n\n

Tipos Comunes de Smart Pointers en Rust<\/h2>\n\n\n\n

Rust ofrece varios smart pointers<\/em> en su est\u00e1ndar, cada uno con diferentes usos y beneficios. Aqu\u00ed veremos algunos de los m\u00e1s importantes:<\/p>\n\n\n\n

Box<T><\/code><\/h3>\n\n\n\n

El m\u00e1s b\u00e1sico de los smart pointers<\/em>, Box<T><\/code>, almacena datos en el heap en lugar del stack. Esto es especialmente \u00fatil para valores grandes o cuando necesitas un tama\u00f1o de tipo que no se conoce en tiempo de compilaci\u00f3n, como en el caso de estructuras recursivas.<\/p>\n\n\n\n

Ejemplo con estructuras recursivas<\/strong>:<\/p>\n\n\n

enum<\/span> List<\/span><\/span> {\n    Cons(i32<\/span>, Box<\/span><List>),  \/\/ `Box<List>` permite que Rust conozca el tama\u00f1o en tiempo de compilaci\u00f3n.<\/span>\n    Nil,\n}\n\nfn<\/span> main<\/span><\/span>() {\n    let<\/span> list = List::Cons(1<\/span>, Box<\/span>::new(List::Cons(2<\/span>, Box<\/span>::new(List::Cons(3<\/span>, Box<\/span>::new(List::Nil))))));\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
En este ejemplo, Box<T><\/code> permite que List<\/code> sea recursivo, ya que cada nodo puede contener otro nodo de la lista.<\/p>\n\n\n\n
Rc<T><\/code> y Arc<T><\/code><\/h3>\n\n\n\n
Rc<T><\/code> es un contador de referencias que permite que m\u00faltiples partes de tu programa compartan el mismo dato en el heap sin necesidad de clonarlo. Arc<T><\/code> es similar, pero es seguro para su uso en m\u00faltiples hilos (concurrencia), utilizando un contador de referencia at\u00f3mico.<\/p>\n\n\n\n
Evitar ciclos de referencia con Weak<T><\/code><\/strong>:<\/p>\n\n\n\n
Uno de los riesgos con Rc<T><\/code> es crear ciclos de referencia, donde dos o m\u00e1s Rc<T><\/code> apuntan entre s\u00ed, impidiendo que Rust libere la memoria porque el conteo de referencias nunca llega a cero. Para evitar esto, puedes usar Weak<T><\/code>.<\/p>\n\n\n\n
Weak<T><\/code> es un tipo de referencia que no incrementa el contador de referencias, lo que significa que no garantiza que el dato siga existiendo cuando se intenta acceder a \u00e9l. Esto permite romper ciclos de referencia, permitiendo que Rust libere la memoria adecuadamente.<\/p>\n\n\n\n
Ejemplo Explicado:<\/strong><\/p>\n\n\n\n
Imaginemos un ejemplo con un \u00e1rbol de nodos donde cada nodo puede tener un padre y m\u00faltiples hijos. Si usamos Rc<T><\/code> para ambos, padres e hijos podr\u00edan formar un ciclo de referencia. Para evitar esto, usamos Weak<T><\/code> para las referencias al padre.<\/p>\n\n\n
use<\/span> std::rc::{Rc, Weak};\nuse<\/span> std::cell::RefCell;\n\nstruct<\/span> Node<\/span><\/span> {\n    value: i32<\/span>,\n    parent: RefCell<Weak<Node>>,  \/\/ Usamos Weak para evitar un ciclo de referencia<\/span>\n    children: RefCell<Vec<\/span><Rc<Node>>>,\n}\n\nfn<\/span> main<\/span><\/span>() {\n    \/\/ Creamos un nodo hijo<\/span>\n    let<\/span> leaf = Rc::new(Node {\n        value: 3<\/span>,\n        parent: RefCell::new(Weak::new()), \/\/ Inicialmente sin padre<\/span>\n        children: RefCell::new(vec!<\/span>[]),\n    });\n\n    \/\/ Creamos un nodo padre<\/span>\n    let<\/span> branch = Rc::new(Node {\n        value: 5<\/span>,\n        parent: RefCell::new(Weak::new()), \/\/ Inicialmente sin padre<\/span>\n        children: RefCell::new(vec!<\/span>[Rc::clone(&leaf)]), \/\/ El hijo apunta al padre<\/span>\n    });\n\n    \/\/ Establecemos la relaci\u00f3n de padre-hijo<\/span>\n    *leaf.parent.borrow_mut() = Rc::downgrade(&branch);\n\n    \/\/ Aqu\u00ed, `leaf` tiene una referencia d\u00e9bil (`Weak`) al `branch`,<\/span>\n    \/\/ por lo que no se crea un ciclo de referencia.<\/span>\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
En este ejemplo:<\/p>\n\n\n\n