Memoria y recolector de basura en Rust: cómo un lenguaje sin GC gestiona los recursos

¿Por qué Rust no necesita un recolector de basura pero sigue siendo seguro?

Cuando los desarrolladores acostumbrados a Python, Java o C# escuchan sobre Rust por primera vez, a menudo les asusta la ausencia del recolector de basura (GC) tradicional. «¿Cómo es posible? —piensan—. ¿Sin GC volveremos a la era de la gestión manual de memoria, fugas y segmentation fault?»

Spoiler: no, no volveremos. Rust ofrece un tercer camino: el sistema de propiedad (ownership), que garantiza la seguridad de la memoria en tiempo de compilación. Sin runtime, sin GC, sin punteros colgantes. Solo reglas claras y un compilador que no te dejará dispararte en el pie.

En este artículo analizaremos cómo está organizada la memoria en Rust, qué son RAII, propiedad, préstamo y tiempos de vida, y por qué todo esto convierte a Rust en uno de los lenguajes de programación de sistemas más fiables.

Cómo está organizada la memoria en Rust: pila y montón

Como en cualquier lenguaje de bajo nivel, la memoria en Rust se divide en dos regiones principales:

\n
• Pila (stack) — memoria rápida y de tamaño limitado que funciona bajo el principio LIFO. Aquí se almacenan variables locales, argumentos de funciones y direcciones de retorno.
\n
• Montón (heap) — memoria más lenta pero flexible, utilizada para datos cuyo tamaño se desconoce en tiempo de compilación (por ejemplo, String, Vec, Box).
\n

En C++ tú decides cuándo asignar y liberar el montón (mediante new/delete). En Java o Python lo hace por ti el recolector de basura, deteniendo el programa periódicamente. Rust, en cambio, utiliza un sistema de propiedad que libera la memoria automáticamente tan pronto como la variable sale del ámbito.

Ejemplo: asignación básica de memoria

fn main() {\n    let s = String::from("¡Hola, mundo!"); // asignación de memoria en el montón\n    println!("{}", s);\n} // aquí s sale del ámbito, la memoria se libera

Observa: no hay free() ni delete. Al final del bloque, el compilador inserta implícitamente una llamada al destructor: drop(). Esto se llama RAII (Resource Acquisition Is Initialization) — el recurso se adquiere al inicializar y se libera al destruir el objeto.

Propiedad (Ownership): la regla principal de Rust

El sistema de propiedad en Rust se basa en tres reglas simples:

\n
1. Cada valor en Rust tiene exactamente un propietario (owner).
\n
2. Cuando el propietario sale del ámbito, el valor se elimina.
\n
3. El propietario puede transferir (move) o prestar temporalmente (borrow) el valor.
\n

¿Suena aburrido? Veamos cómo funciona en la práctica.

Movimiento (Move)

fn main() {\n    let s1 = String::from("hello");\n    let s2 = s1; // s1 se mueve a s2\n    // println!("{}", s1); // ¡Error! s1 ya no posee los datos\n    println!("{}", s2); // OK\n}

En C++ esta asignación resultaría en dos punteros a la misma memoria — y en una doble liberación. En Rust, el compilador simplemente prohíbe usar s1 después del movimiento. Sin fugas, sin eliminaciones dobles.

Copia (Copy)

Los tipos simples, como enteros, valores booleanos y caracteres, implementan el trait Copy. Para ellos, la asignación crea una copia completa:

fn main() {\n    let x = 42;\n    let y = x;\n    println!("x = {}, y = {}", x, y); // ¡Ambos están disponibles!\n}

¿Por qué? Porque i32 se almacena en la pila, y copiarlo es simplemente copiar unos pocos bytes. Barato y seguro.

Préstamo (Borrowing) y referencias

¿Qué hacer si necesitas dar acceso temporal a los datos sin transferir la propiedad? Usar referencias. Rust permite prestar un valor mediante una referencia.

fn main() {\n    let s = String::from(