Nivel 1 · Fundamentos· Lección 4 de 10 · 25 min
Propiedad (ownership)
Las tres reglas que permiten a Rust liberar memoria sin recolector de basura, y por qué un valor movido no puede volver a usarse.
Esta es la lección que hace que Rust sea Rust. Tómatela con calma y ejecuta todos los ejemplos.
El problema
La memoria de un programa es de dos clases. La pila (stack) guarda los valores cuyo tamaño se conoce en tiempo de compilación; se libera automáticamente cuando una función retorna. El montículo (heap) guarda los datos cuyo tamaño puede cambiar, como una cadena que crece. Alguien tiene que decidir cuándo se libera la memoria del heap.
- Si se libera demasiado pronto, algo que todavía apunta a ella lee basura: uso después de liberar (use-after-free).
- Si se libera dos veces: doble liberación (double free), corrupción del heap.
- Si no se libera nunca: una fuga (leak).
Los lenguajes con recolector de basura lo resuelven rastreando en tiempo de ejecución. C lo resuelve confiando en ti. Rust lo resuelve con una disciplina en tiempo de compilación.
Las tres reglas
- Cada valor tiene exactamente un dueño (owner): una variable, un campo, un elemento de una colección…
- Solo hay un dueño a la vez.
- Cuando el dueño sale de ámbito, el valor se libera (drop): se devuelven su memoria y cualquier otro recurso.
fn main() {
{
let s = String::from("hello"); // s es dueña de un búfer en el heap
println!("{s}");
} // s sale de ámbito aquí → el búfer se libera
// println!("{s}"); // s ya no existe
}
Ni free ni recolector. El compilador inserta la limpieza en la llave de cierre.
Movimientos
Un String son tres palabras en la pila —un puntero, una longitud y una capacidad— más un búfer en el heap. ¿Qué debería hacer let b = a;?
Si copiara solo las tres palabras, dos variables apuntarían a un mismo búfer y las dos intentarían liberarlo. Si copiara también el búfer, cada asignación sería una reserva de memoria oculta. Rust no hace ninguna de las dos cosas: copia las tres palabras y después considera que a es inválida. La propiedad se ha movido.
fn main() {
let a = String::from("hello");
let b = a; // la propiedad se mueve de a a b
println!("{b}");
println!("{a}"); // ❌ error[E0382]: préstamo de un valor movido: `a`
}
Ejecútalo y lee el error. El compilador muestra dónde se movió el valor y dónde intentaste usarlo después. Esta única comprobación elimina las dobles liberaciones y el uso después de liberar: siempre hay exactamente un dueño responsable de la limpieza.
Un movimiento cuesta unas pocas palabras de máquina, sin importar lo grandes que sean los datos del heap. Nunca es una copia profunda.
Clone: una copia profunda explícita
Cuando de verdad quieres dos copias independientes, pídelo:
fn main() {
let a = String::from("hello");
let b = a.clone(); // reserva un búfer nuevo y copia los bytes
println!("{a} {b}");
}
.clone() se ve en el código fuente, así que las copias caras nunca se esconden. Mientras aprendes, recurrir a clone para superar un error está bien. Más adelante aprenderás cuándo un préstamo es la mejor herramienta.
Copy: tipos que solo son bits
Los enteros no se comportan como String:
fn main() {
let a = 5;
let b = a;
println!("{a} {b}"); // los dos funcionan
}
Los tipos que viven enteramente en la pila y no poseen nada implementan el trait Copy. Asignarlos duplica los bits y deja el original válido. Entre los tipos Copy están todos los enteros y los de coma flotante, bool, char y las tuplas o arrays formados solo por tipos Copy. Nada que posea una reserva en el heap —String, Vec, Box— es Copy.
La propiedad y las funciones
Pasar un valor a una función lo mueve, exactamente igual que una asignación. Devolver un valor lo mueve hacia fuera.
fn consume(s: String) {
println!("consumed: {s}");
} // s se libera aquí
fn make() -> String {
String::from("fresh") // la propiedad se mueve a quien llama
}
fn main() {
let a = String::from("hello");
consume(a);
// println!("{a}"); // ❌ a se movió dentro de consume
let b = make();
println!("{b}");
}
Tener que devolver un valor cada vez que quieres seguir usándolo sería insoportable:
fn length(s: String) -> (String, usize) {
let n = s.len();
(s, n) // devuelve la propiedad, junto con la respuesta
}
fn main() {
let s = String::from("hello");
let (s, n) = length(s);
println!("{s} has {n} bytes");
}
Esto funciona, pero nadie escribe Rust así. La próxima lección presenta el préstamo (borrowing): dejar que una función use un valor sin tomar su propiedad.
Orden de liberación
Los valores se liberan en orden inverso al de su declaración. Puedes verlo ocurrir:
struct Noisy(&'static str);
impl Drop for Noisy {
fn drop(&mut self) {
println!("dropping {}", self.0);
}
}
fn main() {
let _a = Noisy("a");
let _b = Noisy("b");
{
let _c = Noisy("c");
}
println!("end of main");
}
Este patrón —ligar la limpieza al ámbito— se llama RAII. En Rust gestiona por igual la memoria, los archivos, los cerrojos y las conexiones de red.
Ejercicios
- Arregla este programa de dos formas distintas (una con
clone, otra reordenando las líneas):let s = String::from("x"); let t = s; println!("{s} {t}"); - Escribe
fn shout(s: String) -> Stringque devuelva la cadena en mayúsculas (to_uppercase()). Llámala e imprime el resultado. ¿Qué le ocurre al argumento? - Predice la salida del ejemplo del orden de liberación si añades
drop(_a);(la función estándar que toma la propiedad y libera) antes delet _b.
Solución del 3
Primero se imprime dropping a, inmediatamente en la llamada a drop; después dropping c, end of main y dropping b. drop no tiene nada de especial: es una función que recibe su argumento por valor y lo deja salir de ámbito.
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.Después de
let a = String::from("hi"); let b = a;, ¿qué enlaces se pueden usar?2.Después de
let a = 5; let b = a;, ¿qué enlaces se pueden usar?3.¿Cuándo se libera el búfer en el heap de un
String?