Rust vs C/C++

// 1. Raw pointers (C-style) -- dangerous
int* raw = new int(42);
// ... 200 lines later, do you remember to:
delete raw;  // Easy to forget, double-delete, or use-after-delete

// 2. RAII with smart pointers (modern C++)
#include <memory>
auto unique = std::make_unique<int>(42);
// Freed automatically when unique goes out of scope.
// Better! But...

// 3. You can STILL do dangerous things:
int* danger = unique.get();  // raw pointer extracted
unique.reset();               // memory freed
*danger = 99;                 // USE-AFTER-FREE! Compiles fine.

// 4. Shared ownership adds complexity:
auto shared1 = std::make_shared<int>(42);
auto shared2 = shared1;  // reference count = 2
// Works, but: cyclic references cause leaks,
// reference counting has runtime overhead,
// and thread safety is only for the count, not the data.

fn main() {
    // Ownership is always clear and enforced:
    let s1 = String::from("hello");
    let s2 = s1;  // ownership MOVES to s2

    // println!("{}", s1);  // COMPILE ERROR: s1 is no longer valid

    // Borrowing is controlled:
    let s3 = String::from("world");
    let len = calculate_length(&s3);  // borrow s3 immutably
    println!("{} has length {}", s3, len);  // s3 is still valid

    // Mutable borrows are exclusive:
    let mut s4 = String::from("hello");
    let r1 = &mut s4;
    // let r2 = &mut s4;  // COMPILE ERROR: second mutable borrow
    // let r3 = &s4;      // COMPILE ERROR: immutable borrow while mutably borrowed
    r1.push_str(", world!");
    println!("{}", s4);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}   // s goes out of scope, but it was just a reference,
    // so nothing happens to the owned String.

// C++ -- compiles, crashes at runtime
std::string make_greeting() {
    std::string s = "Hello";
    std::string_view sv = s;  // sv references s's buffer
    return std::string(sv);
    // Wait -- what if we returned sv instead?
    // std::string_view is a non-owning reference.
    // If s is destroyed first, sv dangles. Compiles fine.
}

// Rust -- compile-time error
fn make_greeting() -> &str {        // ERROR: missing lifetime
    let s = String::from("Hello");
    &s  // cannot return reference to local variable
}
// The compiler refuses to compile this.
// You must return the owned String instead.

#include <thread>
#include <vector>

int main() {
    std::vector<int> data;

    // Two threads writing to the same vector
    // with no synchronization:
    std::thread t1([&data]() {
        for (int i = 0; i < 1000; i++)
            data.push_back(i);     // DATA RACE!
    });
    std::thread t2([&data]() {
        for (int i = 0; i < 1000; i++)
            data.push_back(i);     // DATA RACE!
    });

    t1.join();
    t2.join();
    // Undefined behavior: crashes, corruption, or
    // appears to work until production.
}

use std::thread;

fn main() {
    let mut data = vec![];

    // Rust won't let you share a mutable reference
    // across threads:
    thread::spawn(|| {
        data.push(1);  // COMPILE ERROR:
        // closure may outlive the current function,
        // but it borrows 'data', which is owned by
        // the current function.
    });

    // The fix: use Arc<Mutex<T>> for shared mutable state
    use std::sync::{Arc, Mutex};
    let data = Arc::new(Mutex::new(vec![]));

    let data1 = Arc::clone(&data);
    let t1 = thread::spawn(move || {
        for i in 0..1000 {
            data1.lock().unwrap().push(i);  // safe!
        }
    });

    let data2 = Arc::clone(&data);
    let t2 = thread::spawn(move || {
        for i in 0..1000 {
            data2.lock().unwrap().push(i);  // safe!
        }
    });

    t1.join().unwrap();
    t2.join().unwrap();
}

#include <fstream>
#include <string>
#include <stdexcept>

// Can this function throw? You can't tell from the signature.
std::string read_config(const std::string& path) {
    std::ifstream file(path);
    if (!file.is_open()) {
        throw std::runtime_error("Cannot open " + path);
    }
    std::string content;
    // getline can also throw...
    std::getline(file, content);
    return content;
}

// Caller has no indication that this might throw:
void initialize() {
    auto config = read_config("/etc/app.conf");
    // If read_config throws and we don't catch,
    // the exception propagates invisibly up the stack.
}

use std::fs;
use std::io;

// The return type TELLS you this can fail:
fn read_config(path: &str) -> Result<String, io::Error> {
    fs::read_to_string(path)
}

fn initialize() -> Result<(), io::Error> {
    // The ? operator propagates errors explicitly:
    let config = read_config("/etc/app.conf")?;
    //                                        ^
    // If read_config returns Err, this function
    // returns that error immediately. If Ok, the
    // value is unwrapped into 'config'.

    println!("Config: {}", config);
    Ok(())
}

// You MUST handle the Result. Ignoring it is a compiler warning.
fn main() {
    match initialize() {
        Ok(()) => println!("Started successfully"),
        Err(e) => eprintln!("Failed to start: {}", e),
    }
}