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
&stren lugar de&Stringen los parámetros. Un&Stringse convierte en&strautomáticamente, y&stracepta 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
- Escribe
fn largest(xs: &[i32]) -> i32. (Supón que el slice no está vacío.) - Escribe
fn make_plural(word: &mut String)que añada unasal final. - 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.¿Cuántas referencias mutables a un mismo valor pueden estar vivas a la vez?
2.¿Por qué rechaza Rust una función que devuelve una referencia a su propia variable local?
3.¿Cuál es el tipo de
&s[0..5]cuandoses unString?