CodeBlanks Logo Icon CodeBlanks
Login Register

Summary - Ownership

Combine move, Copy and function calls to trace ownership flow.

Ownership summary

Three rules: every value has a single owner; when the owner leaves scope the value is dropped; assignment and function calls move non-Copy values. Copy types (numbers, bool, char, tuples/arrays with Copy fields) are copied. A deep copy is made explicitly with .clone(). Returning transfers ownership to the caller. These rules provide memory safety without a garbage collector.

Thinking in scopes

To see when a value is dropped, look at the curly braces: a value is dropped at the end of the block where its owner was declared. To drop a value earlier you can call drop(value); this is especially useful for releasing locks and large buffers early.

let buyuk = vec![0u8; 10_000_000];
// ... use it ...
drop(buyuk);         // memory freed here
// buyuk can no longer be used

Practice Ownership chain

Let fn yeni_veri() -> String return "veri" and fn tuket(s: String) -> usize return its length. In main, do let s = yeni_veri();, let kopya = s.clone();, let n = tuket(s); and print kopya and n.

Starter code

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

Sample solution

main.rs
fn yeni_veri() -> String {
    String::from("veri")
}

fn tuket(s: String) -> usize {
    s.len()
}

fn main() {
    let s = yeni_veri();
    let kopya = s.clone();
    let n = tuket(s);
    println!("{} {}", kopya, n);
}

Expected output

veri 4

Questions and answers

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

1 Which of these compiles?

  • let v = vec![1]; let w = v; v.len();
  • None
  • let a = 5; let b = a; println!("{a}"); Correct answer
  • let a = String::new(); let b = a; println!("{a}");

Explanation: Because i32 is Copy, a stays valid; String and Vec are moved, so the other two give E0382.

2 Drop early

Question 
let tampon = vec![0u8; 1024];
____(tampon);
Answer 
let tampon = vec![0u8; 1024];
drop(tampon);

Explanation: drop releases the value immediately; the variable can't be used afterwards.

3 Group summary

Term Meaning
Sahip Single
Move Non-Copy types
Copy Copy types
clone Explicit deep copy

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