Ownership y movimientos

Por qué existe la propiedad

Un String reserva un buffer en el heap. Ese buffer debe liberarse una sola vez: si no se libera, se desperdicia memoria; si se libera dos veces o demasiado pronto, el programa puede acceder a memoria que ya no es válida.

Rust evita ese problema sin recolector de basura y sin exigir llamadas manuales a free. Cada valor tiene una única dueña —la variable que lo posee— y, cuando esa dueña sale de scope, Rust ejecuta drop y libera los recursos asociados.

Por eso let s2 = s1; no duplica el buffer de un String: transfiere su propiedad a s2 e invalida s1. Eso es un movimiento. Los tipos Copy sí se duplican de forma implícita; clone crea una duplicación explícita, y una referencia permite usar el valor temporalmente sin convertirse en su dueña.

STACK · s1dueña · struct en stack
ptr0x1
len4
cap4
HEAP · 0x1h · o · l · a

01 / 06UNA DUEÑA

Un valor ocupa dos lugares

String es una cadena UTF-8 ampliable que posee su contenido. El valor mantiene tres datos de control (puntero, longitud y capacidad) y el puntero conduce al buffer de bytes reservado en el heap.

En "hola", la longitud es 4 porque sus cuatro letras ocupan un byte cada una. La capacidad indica cuánto espacio hay reservado y siempre es igual o mayor que la longitud; la escena muestra capacidad 4 como modelo concreto. Mientras s1 sea la dueña, es también responsable de liberar ese buffer al salir de scope.

Cada valor en Rust tiene una dueña: la variable que lo posee. Solo puede haber una a la vez.

lib.rsCompila↗

pub fn crear_string() -> String {
    // La variable vive en el stack y posee el buffer creado en el heap.
    let saludo = String::from("hola");
    saludo
}

// Playground entry point for this example.
fn main() {
    println!("{}", crear_string());
}

Resultado

Asignar transfiere la propiedad

Al ejecutar let s2 = s1, Rust transfiere la propiedad de s1 a s2. Puedes imaginar que se trasladan el puntero, la longitud y la capacidad, pero los bytes de "hola" no se copian y el buffer continúa en la misma reserva del heap.

s1 no queda vacía ni contiene null: simplemente deja de ser una variable válida para usar. Solo s2 podrá acceder al String y liberarlo cuando salga de scope. Así Rust evita que dos variables intenten liberar el mismo buffer.

lib.rsCompila↗

pub fn mover_string() {
    let saludo = String::from("hola");

    // `saludo` es la dueña del buffer en el heap.
    // Al asignarlo a `despedida`, la propiedad se MUEVE:
    let despedida = saludo;

    // A partir de aquí, `saludo` ya no es válido.
    println!("{despedida}");
}

// Playground entry point for this example.
fn main() {
    mover_string();
}

Resultado

Usar la variable anterior es un error

El compilador recuerda que la propiedad salió de s1. Si intentas usarla después, produce E0382: use of moved value y detiene la compilación antes de que pueda existir un acceso a memoria ya liberada o una doble liberación.

La solución depende de la intención: usa s2 si querías transferir el valor, pide una referencia si solo necesitabas consultarlo, o llama a clone() si realmente necesitas dos valores independientes.

lib.rsNo compila↗

fn main() {
    let s = String::from("hola");
    let t = s;          // la propiedad se mueve a `t`
    println!("{s}");    // ERROR: borrow of moved value: `s`
}

Resultado

El compilador dice (E0382)

borrow of moved value: `s`. El compilador señala dónde se movió el valor y dónde intentaste usarlo.

error[E0382]: borrow of moved value: `s`
--> src/main.rs:4:20
|
2 |     let s = String::from("hola");
|         - move occurs because `s` has type `String`,
|           which does not implement the `Copy` trait
3 |     let t = s;
|             - value moved here
4 |     println!("{s}");
|                    ^ value borrowed here after move

Copy duplica el valor, no un recurso

i32 implementa el trait Copy. Por eso let b = a duplica automáticamente sus bits y ambas variables siguen siendo válidas. En este ejemplo cada una contiene su propio entero y no existe ningún buffer en el heap.

Copy no significa «todo lo que vive en el stack». Solo puede implementarse para tipos que pueden duplicarse sin ejecutar lógica especial de liberación; un String posee un recurso y, por tanto, no es Copy.

lib.rsCompila↗

pub fn tipos_copy_no_se_mueven() {
    let x = 42;

    // Los enteros implementan `Copy`: la asignación COPIA el valor,
    // no mueve la propiedad. No hay heap de por medio.
    let y = x;

    // `x` sigue siendo perfectamente válido.
    println!("{x} + {y} = {}", x + y);
}

// Playground entry point for this example.
fn main() {
    tipos_copy_no_se_mueven();
}

Resultado

Clone hace visible el coste

Si necesitas conservar el String original y obtener otro independiente, debes pedirlo explícitamente con clone(). Para String, la operación reserva un segundo buffer y copia en él los bytes UTF-8.

Después del clone hay dos variables válidas, cada una dueña de su buffer y cada una responsable de liberarlo. El coste queda visible en el código. Este comportamiento describe a String; otros tipos pueden implementar Clone compartiendo internamente parte de sus datos.

lib.rsCompila↗

pub fn clonar_para_conservar() {
    let original = String::from("datos importantes");

    // `clone` crea una copia profunda del buffer en el heap:
    // ahora hay DOS dueñas independientes.
    let copia = original.clone();

    // Ambas variables siguen siendo válidas.
    println!("{original} / {copia}");
}

// Playground entry point for this example.
fn main() {
    clonar_para_conservar();
}

Resultado

Si solo necesitas usarlo, pide prestado

Una referencia &T permite pedir prestado un valor: da acceso temporal sin transferir su propiedad. Crear la referencia no duplica el String, no reserva otro buffer y no convierte a la referencia en dueña.

&str es una vista prestada de texto UTF-8. Si una función solo necesita leer una cadena, aceptar &str comunica esa intención y permite usar tanto String como literales. El compilador garantiza que la referencia no se use después de que la variable dueña deje de existir.

lib.rsCompila↗

pub fn longitud_sin_consumir(texto: &str) -> usize {
    // `texto` puede leer el buffer durante este préstamo,
    // pero no se convierte en su dueña.
    texto.len()
}

pub fn usar_prestamo() {
    let saludo = String::from("hola");
    let longitud = longitud_sin_consumir(&saludo);

    // `saludo` conserva la propiedad y sigue siendo válido.
    println!("{saludo} tiene {longitud} bytes");
}

// Playground entry point for this example.
fn main() {
    usar_prestamo();
}

Resultado

.forge-journey { height: auto !important; } .forge-journey__viewport { position: static !important; height: auto !important; display: block !important; } .forge-journey__stage { min-height: auto; overflow: visible; } .forge-journey__fallback { position: static !important; width: auto !important; height: auto !important; margin: 0 !important; clip: auto !important; overflow: visible !important; } .forge-journey__fallback-chapter[hidden] { display: block !important; margin-bottom: 2rem; } .forge-journey__panel { min-height: auto !important; } .forge-journey__chapter { position: static !important; opacity: 1 !important; visibility: visible !important; transform: none !important; border-bottom: 1px solid rgba(255,255,255,.12); } .forge-journey__panel-header, .forge-journey__controls { display: none !important; }

Qué cambia respecto a otros lenguajes

La misma asignación no expresa lo mismo en todos los lenguajes. Si a permite acceder a un valor que usa memoria dinámica, esto es lo habitual:

Lenguaje	Al ejecutar `b = a`	Liberación del recurso
TypeScript / Java	Se copia una referencia gestionada. `a` y `b` permiten acceder al mismo objeto.	El recolector de basura actúa cuando el objeto deja de ser alcanzable.
C++	Un tipo como `std::string` se copia. Para permitir un movimiento puede usarse `b = std::move(a)`; después, `a` sigue siendo válido, pero su estado puede haber cambiado.	Cada objeto libera sus recursos desde su destructor siguiendo RAII; normalmente no se usa `delete` directamente.
Rust	Un tipo como `String` se mueve: `b` recibe el valor y `a` deja de poder utilizarse. Para duplicar también el buffer hay que escribir `a.clone()`.	El recurso se libera mediante `drop` cuando sale de scope su dueña actual.

Rust sí permite varias referencias compartidas &T. Lo que el préstamo impide en código seguro es combinar acceso mutable con otros accesos al mismo valor: puede haber varias referencias compartidas o una referencia mutable, pero no ambas cosas a la vez. El compilador comprueba esta regla y también que ninguna referencia sobreviva al valor al que apunta.

Objetivo

Implementa saludo_mas_largo para devolver uno de los textos recibidos por referencia. Implementa crear_saludo para generar un String nuevo sin consumir el argumento de entrada.

Implementa

Completa una función en cada editor.

Recibe dos &str y devuelve el que tenga mayor longitud.

/// Devuelve el saludo más largo sin tomar la propiedad.
pub fn saludo_mas_largo(a: String, b: String) -> String {
    todo!("devuelve a o b")
}

Recibe un &str y crea un saludo sin consumir el valor de entrada.

/// Construye un saludo nuevo sin consumir el nombre.
pub fn crear_saludo(nombre: String) -> String {
    todo!("construye un String nuevo")
}

Comprueba

Ejecuta las pruebas y corrige el código a partir del diagnóstico de Rust.

Pruebas visibles

devuelve el texto más largoel nombre sigue disponible

Compilador—

Modifica el código antes de ejecutar las pruebas.

Ayuda

Consulta una pista o compara tu implementación con la solución.

Solución comentadaSolución↗

/// Devuelve el saludo más largo sin quedarse con la propiedad
/// de ninguno de los dos: solo pide prestado.
#[must_use]
pub fn saludo_mas_largo<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() >= b.len() { a } else { b }
}

/// Crea un saludo propio a partir de un nombre prestado.
#[must_use]
pub fn crear_saludo(nombre: &str) -> String {
    let mut saludo = String::from("hola, ");
    saludo.push_str(nombre);
    saludo
}

// Playground entry point for this example.
fn main() {
    let corto = "hey";
    let largo = "buenas tardes";
    println!("{}", saludo_mas_largo(corto, largo));
    println!("{}", crear_saludo("rusticiero"));
}

Resultado

Resumen

Cada valor tiene una única dueña (la variable que lo posee); al salir de scope, el valor se libera automáticamente.
Asignar o pasar un valor con datos en el heap mueve la propiedad; la variable anterior queda inválida.
clone() crea una copia profunda explícita cuando de verdad necesitas dos dueñas.
Los tipos Copy (sin heap) se copian en la asignación y ambas variables siguen vivas.
El compilador convierte los errores de memoria en errores de compilación con mensajes accionables.

Fuentes

The Rust Programming Languagech04-01–ch04-03 · Klabnik, Nichols, Krycho y la comunidad de Rust
Rust Standard Librarystd::string::String · Clone · Copy
Rust Compiler Error IndexE0382
Programming Rust, 2nd Editionchapters-4-5 · Blandy, Orendorff, Tindall (O’Reilly, 2021)
Effective Rustitem-15 · Drysdale (O’Reilly)

Por qué existe la propiedad

Qué cambia respecto a otros lenguajes

Completa dos funciones sin consumir los valores de entrada.

Implementa

Seleccionar el texto más largo

Construir un String nuevo

Comprueba

Ayuda

Resumen

Fuentes