Moves and copies

Rust frees memory without a garbage collector. It does this with three simple rules about ownership.

The rules

1. Every value has exactly one owner.
2. When the owner goes out of scope, the value is dropped.
3. Ownership can move to another variable, but there is still only one owner.

String::from("hi") makes a String: text that can grow. s.push('!') adds a char to its end, so s must be let mut.

A scope is the { } block a variable lives in. drop(x) drops a value right away, before its scope ends. After that, x can't be used.

Moves

A String or Vec keeps its data on the heap. Assigning it to another variable moves ownership:

1let a = String::from("hi");2let b = a;          // ownership moves to b3println!("{b}");    // fine4// println!("{a}"); // error E0382: a was moved

Passing a value to a function also moves it. Returning a value moves ownership back to the caller.

format! is handy for making a value to return. It works like println!, but gives back a new String instead of printing it.

1fn shout(s: String) -> String {2    format!("{s}!")3}

Copies

Small types that live on the stack are copied instead of moved. These include integers, floats, bool, char, and tuples made only of them. After let y = x; with an i32, both x and y work.

A struct moves by default. It is copied only if it has #[derive(Clone, Copy)], and that needs every field to be Copy.

Clone

When you want two independent values, call .clone(). It copies the heap data too, so it can be slow for big values.

1let a = String::from("hi");2let b = a.clone();3println!("{a} {b}"); // both work

Remember

• E0382 means "you used a value after it moved".
• If you need the value again, clone it or (next unit) borrow it.