This is just a unique pointer, cannot be cloned, single threaded.
#[derive(Debug)]
struct Person {
pub name: String,
pub age: u32,
}
fn main() {
let mut b = Box::new(Person{name: "Max".into(), age: 54});
b.age = 55;
println!("Name: {}, Age: {}", b.name, b.age);
println!("Byte size: {}", std::mem::size_of::<Box<Person>>());
}
This is a reference counted pointer, can be cloned, if there is only one reference, one can get mutable access. Single threaded.
#[derive(Debug)]
struct Person {
pub name: String,
pub age: u32,
}
fn main() {
let mut b = std::rc::Rc::new(Person{name: "Max".into(), age: 54});
{
let c = b.clone();
println!("Name: {}, Age: {}", c.name, c.age);
}
{
let m = std::rc::Rc::get_mut(&mut b);
if let Some(p) = m {
p.age = 55;
} else {
println!("Cannot get mutable reference!");
}
}
println!("Name: {}, Age: {}", b.name, b.age);
println!("Byte size: {}", std::mem::size_of::<std::rc::Rc<Person>>());
}
Multi-threaded reference counted smart pointer using atomics for the reference count.
#[derive(Debug)]
struct Person {
pub name: String,
pub age: u32,
}
fn main() {
let mut b = std::sync::Arc::new(Person{name: "Max".into(), age: 54});
// let c = b.clone();
{
let m = std::sync::Arc::get_mut(&mut b);
if let Some(p) = m {
p.age = 55;
} else {
println!("Cannot get mutable reference!");
}
}
println!("Name: {}, Age: {}", b.name, b.age);
// println!("Name: {}, Age: {}", c.name, c.age);
println!("Byte size: {}", std::mem::size_of::<std::sync::Mutex::<Person>>());
}
Mutex using the type system to ensure proper usage.
#[derive(Debug)]
struct Person {
pub name: String,
pub age: u32,
}
fn main() {
let b = std::sync::Mutex::new(Person{name: "Max".into(), age: 54});
{
let g = b.lock();
if let Ok(mut p) = g {
p.age = 55;
} else {
println!("Cannot get mutex!");
}
}
{
let g = b.lock().unwrap();
println!("Name: {}, Age: {}", g.name, g.age);
}
println!("Byte size: {}", std::mem::size_of::<std::sync::Mutex::<Person>>());
}
Read/Write lock using the type system to ensure proper usage.
#[derive(Debug)]
struct Person {
pub name: String,
pub age: u32,
}
fn main() {
let b = std::sync::RwLock::new(Person{name: "Max".into(), age: 54});
{
let g = b.write();
if let Ok(mut p) = g {
p.age = 55;
} else {
println!("Cannot get mutex!");
}
}
{
let g = b.read().unwrap();
println!("Name: {}, Age: {}", g.name, g.age);
}
println!("Byte size: {}", std::mem::size_of::<std::sync::RwLock::<Person>>());
}
Single threaded, run-time tracking immutable references and allows one mutable reference at a time.
#[derive(Debug)]
struct Person {
pub name: String,
pub age: u32,
}
fn main() {
let b = std::cell::RefCell::new(Person{name: "Max".into(), age: 54});
{
let c = b.borrow();
println!("Name: {}, Age: {}", c.name, c.age);
}
{
b.borrow_mut().age = 55;
}
println!("Name: {}, Age: {}", b.borrow().name, b.borrow().age);
println!("Byte size: {}", std::mem::size_of::<std::cell::RefCell<Person>>());
}
Single threaded, allows mutation just be moving the value in and out.
#[derive(Debug)]
struct Person {
pub name: String,
pub age: u32,
}
fn main() {
let b = std::cell::Cell::new(Person{name: "Max".into(), age: 54});
b.replace(Person{name: "Max2".into(), age: 55});
let c = b.into_inner();
// println!("Name: {}, Age: {}", b.name, b.age); // not allowed
println!("Name: {}, Age: {}", c.name, c.age);
println!("Byte size: {}", std::mem::size_of::<std::cell::Cell<Person>>());
}
- Rust book: https://doc.rust-lang.org/book/ch15-00-smart-pointers.html
Box
: https://doc.rust-lang.org/std/boxed/index.htmlstd::rc
: https://doc.rust-lang.org/std/rc/index.htmlstd::rc::Rc
: https://doc.rust-lang.org/std/rc/struct.Rc.htmlstd::sync::Arc
: https://doc.rust-lang.org/std/sync/struct.Arc.htmlstd::sync::Mutex
: https://doc.rust-lang.org/std/sync/struct.Mutex.htmlstd::sync::RwLock
: https://doc.rust-lang.org/std/sync/struct.RwLock.htmlstd::cell
: https://doc.rust-lang.org/std/cell/index.htmlstd::cell::RefCell
: https://doc.rust-lang.org/std/cell/struct.RefCell.htmlstd::cell::Cell
: https://doc.rust-lang.org/std/cell/struct.Cell.html- Video: https://youtu.be/f2rlKJ-tX3U
- Overview: https://gist.github.com/max-itzpapalotl/18f7675a60f6f9603250367bcb63992e