Préstamo

La mayoría de las veces, nos gustaría acceder a los datos sin apropiarnos de ellos. Para lograr esto, Rust usa un mecanismo de préstamo. En lugar de pasar objetos por valor (T), los objetos se pueden pasar por referencia (& T).

El compilador garantiza estáticamente (a través de su comprobador de préstamos) que las referencias siempre apunten a objetos válidos. Es decir, mientras existan referencias a un objeto, el objeto no se puede destruir.

// Esta función toma posesión de una caja y la destruye
fn destruye_caja_i32(i32_en_caja: Box<i32>) {
    println!("Destruyendo caja que contiene {}", i32_en_caja);
}

// Esta función pide prestado un i32
fn pide_prestado_i32(i32_prestado: &i32) {
    println!("Este int es: {}", i32_prestado);
}

fn main() {
    // Crea un i32 en caja y un i32 en la pila
    let i32_en_caja = Box::new(5_i32);
    let i32_en_la_pila = 6_i32;

    // Pide prestado el contenido de la caja. La propiedad no se toma, para que los
    // contenidos se puedan volver a tomar prestados.
    pide_prestado_i32(&i32_en_caja);
    pide_prestado_i32(&i32_en_la_pila);

    {
        // Toma una referencia a los datos contenidos dentro de la caja
        let _ref_a_i32: &i32 = &i32_en_caja;

        // ¡Error!
        // No se puede destruir `i32_en_caja` mientras el valor interno se tome prestado
        // más adelante en el ámbito.
        destruye_caja_i32(i32_en_caja);
        // FIXME ^ Comenta esta línea

        // Intenta tomar prestado `_ref_a_i32` después de que se destruya el valor
        // interno
        pide_prestado_i32(_ref_a_i32);
        // `_ref_a_i32` sale de su ámbito y ya no se toma prestado.
    }

    // `i32_en_caja` can now give up ownership to `eat_box` and be destroyed
    destruye_caja_i32(i32_en_caja);
}