FerrousPath

Nivel 1 · Fundamentos· Lección 5 de 10 · 25 min

Referencias y préstamos

Usar un valor sin ser su dueño — referencias compartidas y mutables, la regla del aliasing y los slices.

Prestar en lugar de mover

Una referencia te permite referirte a un valor sin tomar su propiedad. Crear una se llama tomar prestado (borrowing).

fn length(s: &String) -> usize {
    s.len()
} // s es una referencia; aquí no se libera nada

fn main() {
    let s = String::from("hello");
    let n = length(&s); // presta s a la función
    println!("{s} has {n} bytes"); // s sigue siendo nuestra
}

&s crea una referencia; &String es su tipo. La función toma prestada la cadena, la lee, y el préstamo termina cuando la función retorna.

Referencias compartidas y mutables

Hay dos clases de referencias.

Se escribe Puede leer Puede escribir Cuántas a la vez
Compartida &T sí no cualquier número
Mutable (exclusiva) &mut T sí sí exactamente una
fn add_exclamation(s: &mut String) {
    s.push('!');
}

fn main() {
    let mut s = String::from("hello");
    add_exclamation(&mut s);
    add_exclamation(&mut s);
    println!("{s}");
}

Tres cosas tienen que cuadrar: la variable es mut, la llamada dice &mut y el tipo del parámetro es &mut String. La mutación nunca sorprende a quien lee.

La regla: aliasing XOR mutación

En cualquier momento, para cualquier valor, puedes tener o bien

  • cualquier número de referencias compartidas &T, o bien
  • exactamente una referencia mutable &mut T,

pero nunca las dos cosas.

fn main() {
    let mut s = String::from("hello");

    let r1 = &s;
    let r2 = &s;        // correcto: muchos lectores
    let w = &mut s;     // ❌ error[E0502]: no se puede tomar prestado `s` como mutable
                        //    porque también está prestado como inmutable
    println!("{r1} {r2} {w}");
}

¿Por qué tan estricto? Porque «alguien cambia los datos mientras otro los está mirando» es la raíz de una clase enorme de errores. Aquí tienes un clásico, que en C++ compila y corrompe la memoria:

fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];  // apunta dentro del búfer en el heap de v
    v.push(4);          // ❌ puede reubicar el búfer → `first` quedaría colgando
    println!("{first}");
}

El compilador no sabe nada específico sobre los vectores. Solo sabe que push necesita &mut v mientras first es una & viva hacia v, y con eso basta para detectarlo. La misma regla, aplicada entre hilos, es la que impide las carreras de datos.

Los préstamos terminan en su último uso

El ámbito de una referencia dura hasta el último lugar donde se usa, no hasta la llave de cierre. Esto compila:

fn main() {
    let mut s = String::from("hello");

    let r1 = &s;
    println!("{r1}");   // último uso de r1: su préstamo termina aquí

    let w = &mut s;     // ahora sí
    w.push_str(", world");
    println!("{w}");
}

Así que la solución a muchos errores de préstamo es simplemente reordenar: termina de leer y después empieza a escribir.

Sin referencias colgantes

Una referencia nunca puede sobrevivir a aquello a lo que apunta.

fn dangle() -> &String { // ❌ error[E0106]: falta un especificador de lifetime
    let s = String::from("hello");
    &s
} // s se libera aquí, así que la referencia apuntaría a memoria liberada

fn main() {
    let r = dangle();
    println!("{r}");
}

La solución es devolver el propio String y mover la propiedad hacia fuera.

Slices

Un slice es una referencia a una secuencia contigua de elementos: un puntero más una longitud. &str es un slice de texto UTF-8; &[T] es un slice de cualquier tipo de elemento.

fn first_word(s: &str) -> &str {
    match s.find(' ') {
        Some(i) => &s[..i],
        None => s,
    }
}

fn sum(xs: &[i32]) -> i32 {
    let mut total = 0;
    for x in xs {
        total += x;
    }
    total
}

fn main() {
    let sentence = String::from("hello wide world");
    let word = first_word(&sentence);
    println!("{word}");

    let numbers = [10, 20, 30, 40, 50];
    println!("{} {}", sum(&numbers), sum(&numbers[1..4]));
}

Dos costumbres que conviene adoptar ya:

  • Recibe &str en lugar de &String en los parámetros. Un &String se convierte en &str automáticamente, y &str acepta también literales de cadena.
  • Recibe &[T] en lugar de &Vec<T>. Acepta vectores, arrays y partes de cualquiera de ellos.

Como word toma prestado de sentence, el compilador no te dejará vaciar ni modificar sentence mientras word siga en uso. El slice no puede quedar obsoleto.

Ejercicios

  1. Escribe fn largest(xs: &[i32]) -> i32. (Supón que el slice no está vacío.)
  2. Escribe fn make_plural(word: &mut String) que añada una s al final.
  3. Esto no compila. Explica por qué y arréglalo sin clone: let mut v = vec![1, 2, 3]; let last = &v[2]; v.clear(); println!("{last}");
Solución del 3

last es un préstamo compartido hacia v que se sigue usando después de v.clear(), que necesita un préstamo mutable. O bien imprime antes de vaciar, o bien copia el elemento —let last = v[2];—, lo cual funciona porque i32 es Copy y no queda ningún préstamo.

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Cuántas referencias mutables a un mismo valor pueden estar vivas a la vez?

  2. 2.¿Por qué rechaza Rust una función que devuelve una referencia a su propia variable local?

  3. 3.¿Cuál es el tipo de &s[0..5] cuando s es un String?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?