Propiedad y transferencia

Debido a que las variables se encargan de liberar sus propios recursos, los recursos solo pueden tener un propietario. Esto también evita que los recursos se liberen más de una vez. Ten en cuenta que no todas las variables poseen recursos (por ejemplo, [referencias]).

Al hacer asignaciones (let x = y) o transferir argumentos de función por valor (foo(x)), la propiedad de los recursos se transfiere. En lenguaje Rust, esto se conoce como transferencia.

Después de transferir recursos, el propietario anterior ya no se puede utilizar. Esto evita la creación de punteros colgantes.

// Esta función toma posesión de la memoria asignada al montículo 
fn destruye_caja(c: Box<i32>) {
    println! ("Destruyendo una caja que contiene {}", c);

    // `c` se destruye y se libera la memoria
}

fn main() {
    // Entero asignado en la pila
    let x = 5u32;

    // *Copia* `x` en `y` - no se transfieren recursos
    let y = x;

    // Ambos valores se pueden usar de forma independiente
    println!("x es {}, y y es {}", x, y);

    // `a` es un puntero a un entero asignado al _montículo_
    let a = Box::new(5i32);

    println!("a contiene: {}", a);

    // *Transfire* `a` a `b`
    let b = a;
    // La dirección del puntero de `a` se copia (no los datos) a `b`.
    // Ambos son ahora punteros a los mismos datos asignados al montículo, pero `b`
    // ahora lo posee.
    
    // ¡Error! `a` ya no puede acceder a los datos, porque ya no posee la memoria
    // en el montículo
    //println!("a contiene: {}", a);
    // TODO ^ Intenta descomentar esta línea

    // Esta función toma posesión de la memoria asignada en el montículo a `b`
    destruye_caja(b);

    // Dado que la memoria del montículo se ha liberado en este punto, esta acción da
    // como resultado la eliminación de referencias a la memoria liberada, pero el
    // compilador lo prohíbe
    // ¡Error! La misma razón que el error anterior
    //println!("b contiene: {}", b);
    // TODO ^ Intenta descomentar esta línea
}