Understanding Rust's Memory Safety Guarantees

// C code with potential memory bugs
char* get_string() {
    char buffer[100];
    strcpy(buffer, "Hello");
    return buffer;  // Returning pointer to stack memory - undefined behavior!
}

void use_after_free() {
    int* ptr = malloc(sizeof(int));
    *ptr = 42;
    free(ptr);
    printf("%d\n", *ptr);  // Use after free - undefined behavior!
}

void double_free() {
    int* ptr = malloc(sizeof(int));
    free(ptr);
    free(ptr);  // Double free - undefined behavior!
}

fn ownership_basics() {
    {
        let s = String::from("hello");  // s owns the String
        // s is valid here
    } // s goes out of scope, String is automatically dropped
    
    // println!("{}", s);  // Compile error: s is not valid here
}

fn ownership_transfer() {
    let s1 = String::from("hello");
    let s2 = s1;  // Ownership moved from s1 to s2
    
    // println!("{}", s1);  // Compile error: s1 no longer owns the value
    println!("{}", s2);     // OK: s2 owns the value
}

// This pattern prevents use-after-free
fn take_ownership(s: String) {
    println!("{}", s);
} // s is dropped here

fn main() {
    let my_string = String::from("hello");
    take_ownership(my_string);
    // println!("{}", my_string);  // Compile error: value moved
}

// For types that implement Copy (like integers)
fn copy_semantics() {
    let x = 5;
    let y = x;  // x is copied, not moved
    println!("x: {}, y: {}", x, y);  // Both valid
}

struct FileHandle {
    fd: i32,
}

impl Drop for FileHandle {
    fn drop(&mut self) {
        println!("Closing file descriptor {}", self.fd);
        // Actual system call to close file
        unsafe { libc::close(self.fd); }
    }
}

fn automatic_cleanup() {
    let file = FileHandle { fd: 3 };
    // Use file...
} // file.drop() called automatically - no resource leaks!

fn calculate_length(s: &String) -> usize {
    s.len()  // Can read, cannot modify
}

fn multiple_readers() {
    let s = String::from("hello");
    let r1 = &s;
    let r2 = &s;
    let r3 = &s;
    println!("{}, {}, {}", r1, r2, r3);  // All valid simultaneously
}

fn change(s: &mut String) {
    s.push_str(", world");
}

fn borrowing_rules() {
    let mut s = String::from("hello");
    
    let r1 = &mut s;
    // let r2 = &mut s;  // Compile error: cannot borrow as mutable twice
    
    r1.push_str(", world");
    
    // After r1 is done, we can create another mutable reference
    let r2 = &mut s;
    r2.push_str("!");
}

fn invalid_reference() -> &String {
    let s = String::from("hello");
    &s  // Compile error: s doesn't live long enough
}

fn data_race_prevention() {
    let mut data = vec![1, 2, 3];
    let r1 = &data[0];
    // data.push(4);  // Compile error: cannot borrow as mutable
    println!("{}", r1);
    data.push(4);  // OK: r1 no longer used
}

// The lifetime 'a means: the returned reference lives as long as
// the shortest-lived input reference
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn lifetime_example() {
    let string1 = String::from("long string");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(string1.as_str(), string2.as_str());
        println!("{}", result);  // OK: both strings still valid
    }
    // println!("{}", result);  // Compile error: string2 doesn't live long enough
}

struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }
    
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention: {}", announcement);
        self.part
    }
}

fn struct_lifetime() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().unwrap();
    let excerpt = ImportantExcerpt {
        part: first_sentence,
    };
    println!("{}", excerpt.part);
}

// These are equivalent:
fn first_word(s: &str) -> &str {
    &s[..s.find(' ').unwrap_or(s.len())]
}

fn first_word_explicit<'a>(s: &'a str) -> &'a str {
    &s[..s.find(' ').unwrap_or(s.len())]
}

// Lifetime elision rules:
// 1. Each input reference gets its own lifetime
// 2. If one input lifetime, output gets that lifetime
// 3. If multiple inputs with &self, output gets self's lifetime

fn recursive_type() {
    enum List {
        Cons(i32, Box<List>),
        Nil,
    }
    
    let list = List::Cons(1,
        Box::new(List::Cons(2,
            Box::new(List::Cons(3,
                Box::new(List::Nil)
            ))
        ))
    );
}

use std::rc::Rc;

fn shared_ownership() {
    let a = Rc::new(String::from("hello"));
    let b = Rc::clone(&a);  // Increases reference count
    let c = Rc::clone(&a);
    
    println!("{}, {}, {}", a, b, c);
    println!("Reference count: {}", Rc::strong_count(&a));
} // String dropped when last Rc goes out of scope

use std::cell::RefCell;

fn interior_mutability() {
    let data = RefCell::new(5);
    
    {
        let mut val = data.borrow_mut();
        *val += 1;
    } // Mutable borrow ends here
    
    println!("{}", data.borrow());  // Immutable borrow OK
}

use std::thread;
use std::sync::{Arc, Mutex};

fn thread_safety() {
    // Arc for shared ownership across threads
    // Mutex for synchronized access
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("Result: {}", *counter.lock().unwrap());
}

// This would not compile - prevents data races:
fn invalid_sharing() {
    let mut data = vec![1, 2, 3];
    
    thread::spawn(move || {
        data.push(4);  // Thread takes ownership
    });
    
    // data.push(5);  // Compile error: data was moved
}

// Send: Can be transferred between threads
// Sync: Can be referenced from multiple threads

use std::rc::Rc;
use std::sync::Arc;

// Rc is !Send (not Send) - single-threaded only
fn not_send() {
    let rc = Rc::new(5);
    // thread::spawn(move || {
    //     println!("{}", rc);  // Compile error: Rc cannot be sent between threads
    // });
}

// Arc is Send - multi-threaded safe
fn is_send() {
    let arc = Arc::new(5);
    thread::spawn(move || {
        println!("{}", arc);  // OK: Arc can be sent between threads
    });
}

// Unsafe allows:
// 1. Dereferencing raw pointers
// 2. Calling unsafe functions
// 3. Accessing mutable statics
// 4. Implementing unsafe traits
// 5. Accessing union fields

fn unsafe_operations() {
    let mut num = 5;
    
    // Creating raw pointers is safe
    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;
    
    // Dereferencing requires unsafe
    unsafe {
        println!("r1: {}", *r1);
        *r2 = 10;
        println!("r2: {}", *r2);
    }
}

// Unsafe abstraction with safe interface
fn split_at_mut<T>(slice: &mut [T], mid: usize) -> (&mut [T], &mut [T]) {
    let len = slice.len();
    let ptr = slice.as_mut_ptr();
    
    assert!(mid <= len);
    
    unsafe {
        (
            std::slice::from_raw_parts_mut(ptr, mid),
            std::slice::from_raw_parts_mut(ptr.add(mid), len - mid),
        )
    }
}

struct QueryBuilder<'a> {
    table: &'a str,
    conditions: Vec<String>,
}

impl<'a> QueryBuilder<'a> {
    fn new(table: &'a str) -> Self {
        QueryBuilder {
            table,
            conditions: Vec::new(),
        }
    }
    
    fn where_clause(mut self, condition: String) -> Self {
        self.conditions.push(condition);
        self
    }
    
    fn build(self) -> String {
        format!(
            "SELECT * FROM {} WHERE {}",
            self.table,
            self.conditions.join(" AND ")
        )
    }
}

fn builder_usage() {
    let query = QueryBuilder::new("users")
        .where_clause("age > 18".to_string())
        .where_clause("active = true".to_string())
        .build();
    
    println!("{}", query);
}

struct TempFile {
    path: PathBuf,
}

impl TempFile {
    fn new(path: PathBuf) -> io::Result<Self> {
        File::create(&path)?;
        Ok(TempFile { path })
    }
    
    fn write(&mut self, data: &[u8]) -> io::Result<()> {
        let mut file = OpenOptions::new().write(true).open(&self.path)?;
        file.write_all(data)
    }
}

impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = fs::remove_file(&self.path);  // Clean up automatically
    }
}

// Rust's abstractions compile to efficient machine code
fn iterator_example() {
    let sum: i32 = (0..1000)
        .filter(|x| x % 2 == 0)
        .map(|x| x * 2)
        .sum();
    
    // Compiles to the same assembly as:
    let mut sum = 0;
    for i in 0..1000 {
        if i % 2 == 0 {
            sum += i * 2;
        }
    }
}

use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,
    children: RefCell<Vec<Rc<Node>>>,
}

fn tree_structure() {
    let leaf = Rc::new(Node {
        value: 3,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });
    
    let branch = Rc::new(Node {
        value: 5,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![Rc::clone(&leaf)]),
    });
    
    *leaf.parent.borrow_mut() = Rc::downgrade(&branch);
    
    // Weak prevents reference cycles and memory leaks
}

use lazy_static::lazy_static;
use std::sync::RwLock;

lazy_static! {
    static ref CONFIG: RwLock<HashMap<String, String>> = {
        let mut m = HashMap::new();
        m.insert("key".to_string(), "value".to_string());
        RwLock::new(m)
    };
}

fn global_state() {
    // Read access
    {
        let config = CONFIG.read().unwrap();
        println!("{:?}", config.get("key"));
    }
    
    // Write access
    {
        let mut config = CONFIG.write().unwrap();
        config.insert("new_key".to_string(), "new_value".to_string());
    }
}

// C++ vector push_back equivalent
fn vec_push_benchmark() {
    let mut v = Vec::with_capacity(1000);
    for i in 0..1000 {
        v.push(i);  // No bounds checking in release mode
    }
}

// Safe array access with bounds checking
fn safe_access(arr: &[i32], index: usize) -> Option<i32> {
    arr.get(index).copied()  // Returns None if out of bounds
}

// Unsafe for performance-critical code
fn unsafe_access(arr: &[i32], index: usize) -> i32 {
    unsafe {
        *arr.get_unchecked(index)  // No bounds checking
    }
}