Rust: un vistazo más (3)

En Rust existe una propiedad llamada ``Ownership``, la cual es: la característica especial que permite a Rust garantizar la seguridad de la memoria sin necesidad de un recolector de basura.

Ownership: es el un conjunto de reglas que rigen la forma en que un programa de Rust administra la memoria.

Esta característica permite que la memoria se administre a través de un sistema de propiedad con un conjunto de reglas que el compilador verifica. Si se viola alguna de las reglas, el programa no se compilará.

Heap, Stack y Garbage collection

• Heap:  son secciones de memoria que se utilizan para almacenar datos en un programa.
• Stack: es una estructura simple que se usa para variables locales y llamadas a funciones.
• Garbage collection: es un recolector de basura, un proceso automático que libera memoria de un programa.

Reglas básicas de Ownership

• Cada valor en Rust tiene un propietario ; si se transfiere la propiedad (move), el propietario anterior pierde acceso. 
• Solo puede haber un propietario a la vez. 
• Cuando el propietario queda fuera del ámbito, el valor se elimina.

Ownership es un concepto clave que gestiona la memoria de forma segura y eficiente sin necesidad de un recolector de basura. La idea principal es que cada valor en Rust tiene un único "propietario" (owner) en un momento dado, y cuando ese propietario sale del ámbito (scope), el valor se libera automáticamente.

Tengamos un caso como el siguiente:

fn main() {
    let s1 = String::from("Hola"); // s1 es el propietario del valor "Hola"
    let s2 = s1;                   // La propiedad se transfiere (move) a s2, s1 ya no es válido
    println!("{}", s2);           // Funciona, imprime "Hola"
    // println!("{}", s1);        // Esto daría error, porque s1 ya no tiene la propiedad
}

En este caso, s1 transfiere la propiedad del String a s2. Si intentamos usar s1 después, Rust nos lo impide en tiempo de compilación para evitar errores de memoria.

Si queremos usar un valor sin transferir propiedad, puedes usar referencias (&) o clonar el dato con .clone(). Veamos el mismo código, pero usando referencias.

fn main() {
    let s1 = String::from("Hola"); // s1 es el propietario
    let s2 = s1.clone();           // s2 obtiene una copia de "Hola", s1 sigue siendo propietario de su instancia
    println!("{}", s2);           // Imprime "Hola" (copia)
    println!("{}", s1);           // Imprime "Hola" (original)
}

s2 tiene su propia copia del valor, y s1 no se ve afectado. A diferencia del ejemplo original con move, ambos son accesibles.

• Referencia (&): Presta el valor, sin copiar, más eficiente. 
• Clonación (.clone()): Crea una copia nueva, más costoso pero independiente.

Continuaremos con Rust en próximas entregas.

Enlaces:

https://www.rust-lang.org
https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html