CodeBlanks Logo Icon CodeBlanks
Login Register

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.

Practice 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).

Starter code

main.rs
fn main() {
    // buraya yaz
}

Sample solution

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

Expected output

kitap kitap

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 What is used to get a real copy of a <code>String</code>?

  • &a
  • copy(a)
  • .clone() Correct answer
  • let b = a;

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

2 Deep copy

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

Explanation: clone copies the heap data and creates an independent new value.

3 Operation and result

Term Meaning
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

All lessons in Beginner

1 Rust basics

  1. What is Rust?
  2. Project with Cargo
  3. Your first program
  4. println! and formatting
  5. Comments
  6. Summary - Rust basics

2 Variables

  1. Variables with let
  2. Mutability with mut
  3. Constants with const
  4. Static variables
  5. Shadowing
  6. Summary - Variables

3 Data types

  1. Integers
  2. Floating point
  3. Bool and char
  4. Tuple
  5. Array
  6. Summary - Data types

4 Strings

  1. &str vs String
  2. Creating a String
  3. Concatenating strings
  4. format! macro
  5. String length
  6. Summary - Strings

5 Project: Calculator

  1. Project skeleton
  2. Reading input
  3. Computing
  4. Error handling
  5. Loop and exit

6 Functions

  1. Defining with fn
  2. Parameters
  3. Return value
  4. Expressions and statements
  5. Early return
  6. Summary - Functions

7 Control flow

  1. if-else
  2. match basics
  3. loop
  4. while loop
  5. for loop
  6. Summary - Control flow

8 Ownership

  1. What is ownership?
  2. Move semantics
  3. Copy trait
  4. Functions and ownership
  5. Return and ownership
  6. Summary - Ownership

9 Borrowing

  1. References
  2. Mutable reference
  3. Borrowing rules
  4. Dangling reference
  5. References and functions
  6. Summary - Borrowing

10 Slices

  1. String slices
  2. Slice syntax
  3. Array slices
  4. Slices and functions
  5. Range types
  6. Summary - Slices

11 Project: Guessing game

  1. Game skeleton
  2. Reading input
  3. Comparing numbers
  4. Random number
  5. Loop and exit

12 Structs

  1. Struct definition
  2. Creating an instance
  3. Tuple struct
  4. Unit-like struct
  5. Field update
  6. Summary - Structs

13 Methods

  1. impl block
  2. self parameter
  3. &mut self
  4. Associated functions
  5. Multiple impl blocks
  6. Summary - Methods

14 Enums

  1. Enum definition
  2. Variants
  3. Variants with data
  4. Option<T>
  5. Option instead of null
  6. Summary - Enums

15 Pattern matching

  1. match patterns
  2. Value binding
  3. if let
  4. while let
  5. _ wildcard
  6. Summary - Pattern matching

16 Project: To-do CLI

  1. Task model
  2. Adding
  3. Listing
  4. Marking done
  5. Reading commands

17 Vectors

  1. Vec<T>
  2. Push and pop
  3. Index and get
  4. Looping a vector
  5. with_capacity
  6. Summary - Vectors

18 Advanced strings

  1. String and &str conversion
  2. chars and bytes
  3. Slicing strings
  4. contains and replace
  5. split and join
  6. Summary - Advanced strings

19 Error handling

  1. Result<T, E>
  2. panic!
  3. ? operator
  4. match and Result
  5. unwrap and expect
  6. Summary - Error handling

20 Beginner final

  1. Vowel counter
  2. Average calculator
  3. Bank account
  4. Temperature converter