Move semantics

See how ownership transfers through moves.

Move semantics

When a value holding heap data, such as a String, is assigned to another variable, the data isn't copied; ownership moves. The old variable becomes invalid:

let a = String::from("kitap");
let b = a;               // ownership moved to b
// println!("{a}");      // error E0382: use of a moved value
println!("{b}");

This way two variables never try to free the same memory twice (a double-free bug becomes impossible).

clone is explicit

Rust doesn't hide copies: an expensive deep copy always appears in the code as .clone().

let a = String::from("kitap");
let b = a.clone();      // new memory is allocated
println!("{a} {b}");    // both are valid

A move is cheap (only the pointer, length and capacity are copied); that's why Rust chooses moving by default. In most cases using a reference (&a) is better than clone.

Exercise Move and copy

Declare let a = String::from("kitap");. Copy it with let b = a.clone(); and move it with let c = a;. Print b and c on one line (a must no longer be used).

Show example solution

fn main() {
    let a = String::from("kitap");
    let b = a.clone();
    let c = a;
    println!("{} {}", b, c);
}

Test yourself

What is used to get a real copy of a <code>String</code>?
- &a
- copy(a)
- .clone()
- let b = a;
Show answer

.clone() — clone makes a deep copy of the heap data, giving two independent Strings. Because it can be expensive, it is written explicitly.

Deep copy

let a = vec![1, 2, 3];
let b = a.____();
println!("{:?} {:?}", a, b);

Show answer

let a = vec![1, 2, 3];
let b = a.clone();
println!("{:?} {:?}", a, b);

Operation and result

let b = a; (String)

Move, a invalid
let b = a.clone();

Deep copy, both valid
E0382

Use of a moved value
Cost of a move

Only 3 words

Next lesson: Copy trait

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies