Ownership and moves

Why ownership exists

A String allocates a buffer on the heap. That buffer must be released exactly once: failing to release it wastes memory; releasing it twice or too early can make the program access memory that is no longer valid.

Rust prevents that problem without a garbage collector and without requiring manual calls to free. Every value has a single owner and, when that owner goes out of scope, Rust runs drop and releases its associated resources.

That is why let s2 = s1; does not duplicate a String buffer: it transfers ownership to s2 and invalidates s1. This is a move. Copy types are duplicated implicitly; clone creates an explicit duplicate, while a reference lets code use the value temporarily without becoming its owner.

STACK · s1owner · stack struct
ptr0x1
len4
cap4
HEAP · 0x1h · o · l · a

01 / 06ONE OWNER

One value occupies two places

String is a growable UTF-8 string that owns its contents. The value keeps three pieces of control data—a pointer, a length and a capacity—and the pointer leads to the byte buffer allocated on the heap.

In "hola", the length is 4 because each of its four letters occupies one byte. Capacity is the amount of reserved space and is always at least the length; the scene uses capacity 4 as a concrete model. While s1 is the owner, it is also responsible for freeing that buffer when it leaves scope.

Every value in Rust has an owner. There can only be one at a time.

lib.rsCompiles↗

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());
}

Result

Assignment transfers ownership

When let s2 = s1 runs, Rust transfers ownership from s1 to s2. You can think of the pointer, length and capacity as moving across, while the bytes of "hola" are not copied and the buffer remains in the same heap allocation.

s1 does not become empty or contain null: it simply stops being a variable that may be used. Only s2 can access the String and free it when it leaves scope. This prevents two variables from trying to free the same buffer.

lib.rsCompiles↗

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();
}

Result

Using the previous variable is an error

The compiler remembers that ownership left s1. Using it afterwards produces E0382: use of moved value, and compilation stops before a use-after-free or double free can occur.

The correct fix depends on your intent: use s2 if you meant to transfer the value, borrow it if you only needed to inspect it, or call clone() if you genuinely need two independent values.

lib.rsDoes not compile↗

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

Result

The compiler says (E0382)

borrow of moved value: `s`. The compiler points to the move and the later invalid use.

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 duplicates a value, not a resource

i32 implements the Copy trait. Therefore let b = a automatically duplicates its bits and both variables remain valid. In this example each variable contains its own integer and no heap buffer exists.

Copy does not mean “everything stored on the stack.” It is limited to types that can be duplicated without special cleanup logic; String owns a resource and therefore is not Copy.

lib.rsCompiles↗

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();
}

Result

Clone makes the cost visible

If you need to preserve the original String and obtain an independent one, request it explicitly with clone(). For String, this allocates a second buffer and copies the UTF-8 bytes into it.

After cloning, both values are valid, each owns its own buffer and each will free that buffer. The cost is visible in the source. This describes String; other types may implement Clone while internally sharing some data.

lib.rsCompiles↗

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();
}

Result

If you only need to use it, borrow it

A reference &T lets you borrow a value: it grants temporary access without transferring ownership. Creating the reference does not duplicate the String, allocate another buffer or make the reference an owner.

&str is a borrowed view of UTF-8 text. When a function only needs to read a string, accepting &str communicates that intent and works with both String values and string literals. The compiler ensures that the reference is not used after the owning value stops existing.

lib.rsCompiles↗

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();
}

Result

.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; }

What changes compared with other languages

The same assignment does not express the same operation in every language. If a provides access to a value backed by dynamically allocated memory, the usual behavior is:

Language	When `b = a` runs	Releasing the resource
TypeScript / Java	A managed reference is copied. Both `a` and `b` provide access to the same object.	The garbage collector acts after the object becomes unreachable.
C++	A type such as `std::string` is copied. A move may be enabled with `b = std::move(a)`; afterwards, `a` remains valid but its state may have changed.	Each object releases its resources from its destructor through RAII; direct use of `delete` is normally unnecessary.
Rust	A type such as `String` is moved: `b` receives the value and `a` can no longer be used. Duplicating the buffer requires an explicit `a.clone()`.	The resource is released through `drop` when its current owner leaves scope.

Rust does allow multiple shared references, &T. In safe code, borrowing prevents mutable access from overlapping with any other access to the same value: there may be several shared references or one mutable reference, but not both at the same time. The compiler checks this rule and also ensures that no reference outlives the value it points to.

Objective

Implement saludo_mas_largo to return one of the texts received by reference. Implement crear_saludo to create a new String without consuming the input argument.

Implement

Complete one function in each editor.

Accept two &str values and return the longest one.

/// 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")
}

Accept an &str and create a greeting without consuming the input value.

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

Check

Run the tests and correct the code using the Rust diagnostic.

Visible tests

returns the longest textthe name remains available

Compiler—

Modify the code before running the tests.

Help

View a hint or compare your implementation with the solution.

Commented solutionSolution↗

/// 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"));
}

Result

Summary

Every value has a single owner; when it leaves scope, the value is freed automatically.
Assigning or passing a value with heap data moves ownership; the previous variable becomes invalid.
clone() creates an explicit deep copy when you truly need two owners.
Copy types (no heap) are copied on assignment and both variables stay alive.
The compiler turns memory errors into compile errors with actionable messages.

Sources

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)

Why ownership exists

What changes compared with other languages

Complete two functions without consuming their input values.

Implement

Select the longest text

Build a new String

Check

Help

Summary

Sources