Idiomatic Rust Snippets

What is pointers and how they are used in Rust?

In Rust, pointers are types that represent memory addresses. Rust provides several types of pointers, each with different characteristics and use cases. Pointers are used to reference data stored in memory, and Rust's ownership and borrowing rules ensure that pointers are used safely.

Types of Pointers in Rust

References: Immutable and mutable references.
Smart Pointers: Box, Rc, Arc, and others.
Raw Pointers: Unsafe pointers.

References

References are the most common type of pointer in Rust. They allow you to borrow data without taking ownership. There are two types of references:

Immutable References (&T): Allow you to read data but not modify it.
Mutable References (&mut T): Allow you to modify data.

fn main() {
    let x = 5;
    let y = &x; // Immutable reference
    println!("y: {}", y);

    let mut z = 10;
    let w = &mut z; // Mutable reference
    *w += 5;
    println!("z: {}", z);
}

Smart Pointers

Smart pointers are data structures that not only act like a pointer but also have additional capabilities, such as automatic memory management. Common smart pointers in Rust include:

Box: A heap-allocated pointer.

fn main() {
    let b = Box::new(5);
    println!("b: {}", b);
}

Rc: A reference-counted pointer for single-threaded scenarios.

use std::rc::Rc;

fn main() {
    let a = Rc::new(5);
    let b = Rc::clone(&a);
    println!("a: {}, b: {}", a, b);
}

Arc: An atomic reference-counted pointer for multi-threaded scenarios.

use std::sync::Arc;
use std::thread;

fn main() {
    let a = Arc::new(5);
    let b = Arc::clone(&a);

    let handle = thread::spawn(move || {
        println!("b: {}", b);
    });

    println!("a: {}", a);
    handle.join().unwrap();
}

Raw Pointers

Raw pointers are unsafe pointers that can be used to perform low-level memory manipulation. They are not subject to Rust's borrowing rules and must be used within an unsafe block.

Immutable Raw Pointer (*const T): Points to data that cannot be modified.
Mutable Raw Pointer (*mut T): Points to data that can be modified.

fn main() {
    let x = 5;
    let y = &x as *const i32; // Immutable raw pointer

    let mut z = 10;
    let w = &mut z as *mut i32; // Mutable raw pointer

    unsafe {
        println!("y: {}", *y);
        *w += 5;
        println!("z: {}", *w);
    }
}