Las reglas de Ownership

El Ownership (propiedad) es la característica más distintiva de Rust. Permite al lenguaje garantizar la seguridad de la memoria sin necesidad de un Garbage Collector ni de obligarte a desasignar manualmente la memoria heap (como en C o C++).

Las Tres Reglas del Ownership

La gestión de la memoria en Rust está gobernada por tres simples reglas controladas rigurosamente por el compilador:

1. Cada valor en Rust tiene una variable llamada su propietario (owner).
2. Solo puede haber un propietario a la vez.
3. Cuando el propietario sale del ámbito (scope), el valor se elimina automáticamente.

Stack vs Heap

Para comprender el ownership, es importante saber dónde residen los datos:

• Stack (Pila): almacena datos de tamaño fijo y conocido en el momento de la compilación (ej. enteros, booleanos). El acceso es extremadamente rápido.
• Heap (Montículo): almacena datos de tamaño dinámico y desconocido en el momento de la compilación (ej. String). La asignación es más lenta y requiere un puntero almacenado en el Stack.

El concepto de "Move" (Desplazamiento)

Cuando asignamos una variable almacenada en el Heap a otra, Rust mueve (o transfiere) la propiedad del valor, invalidando la primera variable:

let s1 = String::from("ciao");
let s2 = s1; // La proprieta del testo si sposta a s2. s1 NON e piu utilizzabile!

// println!("{}", s1); // ERRORE DI COMPILAZIONE! s1 e "borrow of moved value"
println!("{}", s2); // Valido!

Este comportamiento evita el problema del "double free error" (intentar liberar la misma memoria dos veces al salir del ámbito), ya que solo s2 liberará la memoria.

El concepto de "Clone" (Copia Profunda)

Si tenemos la necesidad explícita de copiar todo el contenido de una String (tanto los punteros en la pila como los datos textuales reales en el montículo), podemos recurrir al método .clone(). Esto duplica completamente los datos en el heap, manteniendo válidas tanto la variable original como la nueva, a costa de un rendimiento debido a la nueva asignación de memoria:

let s1 = String::from("ciao");
let s2 = s1.clone(); // Copia profonda. Entrambe le variabili rimangono valide!
println!("s1: {}, s2: {}", s1, s2);

El concepto de "Copy"

Para los tipos simples guardados completamente en el Stack (como enteros i32, booleanos bool, caracteres char), la asignación realiza una verdadera copia superficial automática, por lo que ambas variables siguen siendo válidas:

let x = 5;
let y = x; // Copia il valore 5 nello stack. Entrambe le variabili sono utilizzabili!
println!("x: {}, y: {}", x, y); // Valido!

Pruébalo tú