Memory Management Across Languages with Simple Analogies | A Large Scale Analysis of Borrow Pattern in Rust

Let's look at how memory is managed in multiple languages first.

Imagine you're renting bikes from a shop:

C/C++: Manual Memory Management

• You have to manually pick up the bike (malloc) and return it yourself (free).
• Risks:
• You might forget to return the bike (memory leak).
• If someone else uses the bike after you return it but before it's cleaned (dangling pointer), it could lead to crashes or accidents.

#include <stdlib.h>
#include <stdio.h>

int main() {
  int* num = (int*)malloc(sizeof(int)); // Allocate memory
  *num = 42;
  printf("Number: %d\n", *num);
  // free(num); // If you forget this, it causes a memory leak
  return 0;
}

Java/Python: Garbage Collection

You rent bikes, but there's an assistant who watches when bikes are not used and automatically returns them.

Benefit: No need to worry about returning bikes.

Drawback: The assistant might decide to clean all bikes at once (garbage collection), which can slow everything down unexpectedly.

public class Main {
    public static void main(String[] args) {
        String data = new String("Hello, World!");
        System.out.println(data); 
  // Java's garbage collector will clean up `data` automatically
    }
}

Rust: Ownership and Borrowing:

The bike shop assigns each bike to one specific person (owner).

• You cannot leave the bike unattended or let someone else use it unless:
• Transfer Ownership: You explicitly hand it over to someone else.
• Borrow: Let someone use the bike temporarily under strict rules:
• Read-only borrow: They can only look at the bike.
• Exclusive borrow: They can adjust the gears but no one else can use the bike at the same time.

The shop ensures all bikes are accounted for when customers leave.

fn main() {
// A bike is assigned to the first owner.
let bike = String::from("Mountain Bike"); // Ownership created
println!("First owner has the bike: {}", bike);


// Transfer ownership to a new person.
let new_owner = bike; // Ownership moved

// println!("{}", bike); // Error: `bike` is no longer valid.
println!("Ownership transferred to new person: {}", new_owner);


// Borrow the bike temporarily (read-only).
let borrowed_bike = &new_owner; // Immutable borrow
println!("The bike is borrowed temporarily: {}", borrowed_bike);


 // Borrowing ends, and the bike remains with the new owner.
}