Ownership y borrowing, explicados sin dolor

Ownership (propiedad) es lo primero que confunde en Rust, y también lo que hace posible todo lo demás. Se resume en tres reglas:

1. Cada valor tiene un único dueño.
2. Solo puede haber un dueño a la vez.
3. Cuando el dueño sale de alcance, el valor se libera.

Mover: regalar el libro

fn main() {
    let a = String::from("hola");
    let b = a; // el valor pasa a `b`
    println!("{a}"); // error[E0382]: borrow of moved value: `a`
}

Al asignar a a b, el dueño cambia. Rust impide usar a después, y así evita que dos variables liberen la misma memoria.

Prestar: el préstamo

Con & prestas el valor sin entregarlo:

fn imprimir(texto: &String) {
    println!("{texto}");
}

fn main() {
    let s = String::from("hola");
    imprimir(&s);
    println!("{s}"); // `s` sigue siendo válido
}

La regla de los préstamos

En un momento dado, puedes tener una de estas dos cosas, nunca ambas:

• Cualquier número de referencias de lectura (&T).
• Exactamente una referencia de escritura (&mut T).

Esta regla evita que alguien modifique un dato mientras otra parte del programa lo está leyendo. Por eso este código no compila:

fn main() {
    let mut v = vec![1, 2, 3];
    let primero = &v[0];
    v.push(4); // error[E0502]
    println!("{primero}");
}

No es un capricho: push puede mover el vector a otra zona de memoria, y primero quedaría apuntando a memoria liberada. En C++, este error compila.

Sin recolector de basura

Estas reglas permiten algo poco común: Rust sabe en qué línea exacta se libera cada valor, sin un proceso que lo busque mientras el programa corre. Si vienes de Java, Go o Python, ese es el gran cambio. Lo comparamos en detalle en Recolector de basura vs. Rust.

Cómo avanzar sin pelear

• Empieza pasando referencias (&T) a tus funciones.
• Si el compilador se queja, usa .clone() sin culpa mientras aprendes.
• Lee el mensaje de error completo. Suele traer la solución.

El siguiente paso natural es entender cuánto dura un préstamo.