Rust – Referencias y préstamos

Como las reglas de propiedad de Rust dicen un propietario a la vez, pero puede haber algunos casos en los que necesitemos realizar una acción en los datos sin afectar su valor original. Esto se hace a través de préstamos. Tomar prestado es como en general cuando tomamos prestado algo, y terminamos con eso, lo devolvemos, pero esto no nos convierte en dueños de los datos. La referencia es una dirección que se pasa a una función como argumento, y siempre comienzan con ampersand (&).

Reglas de Referencias

• En cualquier momento, puede tener una referencia mutable o cualquier cantidad de referencias inmutables.
• Las referencias deben ser siempre válidas.

Tomemos un ejemplo

fn main() {
    let gfg = String::from("geeksforgeeks");
    
    // gfg is passed as reference
    let length = calculate_length(&gfg); 
  
    // gfg goes out of scope
    println!("The length of '{}' is {}.", gfg, length);
} 
  
fn calculate_length(gfg_len: &String) -> usize { 
    
    // gfg_len variable expecting string reference
    // returning length
    gfg_len.len() 
}

La variable gfg contiene una string y se pasa a una función calcular_longitud como referencia, lo que significa que gfg_len toma prestado el valor de la variable gfg para calcular su longitud y devuelve lo prestado al final de la función. Luego, la función devuelve la longitud de la string de referencia pasada.

referencia

Representación Visual de Referencias:

representación visual

Ahora intentemos cambiar el valor del programa prestado y veamos qué obtenemos

fn main() {
    let old = String::from("geeks");
    complete(&old);
}
fn complete(new: &String) { 
    new.push_str(", forgeeeks");
    println!("{}", new);
}

Referencias y Mutabilidad

Al igual que las variables en Rust, todas las referencias son mutables de forma predeterminada. Intentemos cambiar el valor al que nos referimos.

fn main() {
    let old = String::from("geeksforgeeks");
    change_reference(&old);
    println!("Old name = {}",old);
}
fn change_reference(new: &String) { 
    *new = String::from("GeeksForGeeks");
    println!("New name = {}", new);
}

Esto da un error porque los valores prestados no se pueden modificar porque no somos los propietarios del valor.

Referencias mutables

Rust admite referencias mutables, lo que significa que podemos cambiar el valor al que hace referencia si es una variable mutable. Hay algunas restricciones sobre cómo usamos las referencias mutables.

• Solo puede tener una referencia mutable a un valor particular en un ámbito particular para evitar carreras de datos
• Si la referencia inmutable existe en nuestro programa, entonces no podemos tener una referencia mutable en el mismo valor.
• Puede tener múltiples referencias inmutables en un ámbito particular porque no podemos cambiar el valor al que hace referencia

Cambiemos el programa anterior para que sea válido.

fn main() {
    let mut old = String::from("geeksforgeeks");
    println!("Old name = {}",old);
    change_reference(&mut old);
}
fn change_reference(new: &mut String) { 
    *new = String::from("GeeksForGeeks");
    println!("New name = {}", new);
}