Rust Unsafe

// Creating raw pointers (safe — no dereference yet)let x = 42u32;let ptr: *const u32 = &x;let mut_ptr: *mut u32 = &mut some_val as *mut u32;
// Null pointerlet null: *const u32 = std::ptr::null();let null_mut: *mut u32 = std::ptr::null_mut();
// Dereference (unsafe)let val = unsafe { *ptr };
// Null checkif !ptr.is_null() {    let val = unsafe { *ptr };}
// Offset (safe to compute, unsafe to dereference)let arr = [1u32, 2, 3, 4, 5];let p = arr.as_ptr();let third = unsafe { *p.add(2) };   // arr[2]let also_third = unsafe { *p.offset(2) };
// Slice from raw partslet slice: &[u32] = unsafe {    std::slice::from_raw_parts(p, arr.len())};

// Declare unsafe function (callers must uphold invariants)/// # Safety/// `ptr` must be non-null and aligned to `T`, and point to initialized data./// The caller must ensure no other mutable reference to the same location exists.unsafe fn read_ptr<T>(ptr: *const T) -> T {    ptr.read()  // ptr::read is unsafe}
// Call unsafe functionlet val = unsafe { read_ptr(some_ptr) };
// Unsafe trait — implementor must uphold safety invariantsunsafe trait MyUnsafeTrait {    fn operation(&self);}
// Implementing an unsafe trait is unsafeunsafe impl MyUnsafeTrait for MyType {    fn operation(&self) { /* must uphold the trait's invariants */ }}
// Send and Sync// Send: type can be moved to another thread// Sync: type can be shared between threads (&T is Send)unsafe impl Send for MyType {}unsafe impl Sync for MyType {}

// The golden rule: unsafe blocks should be small, isolated, and// wrapped in a safe API that maintains the invariant
pub struct MyVec<T> {    ptr: *mut T,    len: usize,    cap: usize,}
impl<T> MyVec<T> {    pub fn new() -> Self {        MyVec { ptr: std::ptr::NonNull::dangling().as_ptr(), len: 0, cap: 0 }    }
    // Safe public API    pub fn get(&self, index: usize) -> Option<&T> {        if index < self.len {            // Safety: index < len guarantees ptr+index is in bounds and initialized            Some(unsafe { &*self.ptr.add(index) })        } else {            None        }    }
    // # Safety comment documents the invariant    pub fn push(&mut self, val: T) {        if self.len == self.cap {            self.grow();        }        // Safety: len < cap after grow(), so ptr+len is in bounds        unsafe { self.ptr.add(self.len).write(val) };        self.len += 1;    }}
// Implement Drop to clean upimpl<T> Drop for MyVec<T> {    fn drop(&mut self) {        // Safety: ptr was allocated with this layout, and all elements are initialized        unsafe {            std::ptr::drop_in_place(std::slice::from_raw_parts_mut(self.ptr, self.len));            std::alloc::dealloc(self.ptr as *mut u8,                std::alloc::Layout::array::<T>(self.cap).unwrap());        }    }}

// transmute: reinterpret bits of one type as another// Both types must have the same size
// Safe uses:let x: u32 = 0x3f800000;let f: f32 = unsafe { std::mem::transmute(x) };  // bits → float
// Transmute slice pointer (sound if types have same size/align)let bytes: &[u8] = &[0x00, 0x00, 0x80, 0x3f];let floats: &[f32] = unsafe {    std::slice::from_raw_parts(bytes.as_ptr() as *const f32, 1)};
// Prefer safe alternatives when available:let f = f32::from_bits(x);         // instead of transmute for float bitslet n = u32::from_ne_bytes(bytes); // instead of transmute for byte arrays

use std::cell::UnsafeCell;
// UnsafeCell is the only way to mutate through a shared referencestruct MyCell<T> {    value: UnsafeCell<T>,}
impl<T: Copy> MyCell<T> {    fn new(val: T) -> Self {        MyCell { value: UnsafeCell::new(val) }    }
    fn get(&self) -> T {        // Safety: single-threaded, no concurrent mutation        unsafe { *self.value.get() }    }
    fn set(&self, val: T) {        // Safety: single-threaded, no outstanding references        unsafe { *self.value.get() = val }    }}