Box: A Smarter Pointer

The Box type serves as a pointer to data allocated on the heap rather than the stack. It operates similarly to smart pointers in C++. When a Box instance goes out of scope, its destructor is triggered, cleaning up the internal objects and freeing the heap memory.

Using Box is quite straightforward in Rust:

fn main() {

let b = Box::new(5);

println!("b={}", b);

}

Box types are particularly useful in three main situations:

1. Unknown Size at Compile Time:

   When dealing with types whose size is not known during compilation, such as in recursive data structures. For instance, consider the ConsList type:

enum List {

Cons(i32, List),

Nil,

}

fn main() {

let list = List::Cons(0, List::Cons(1, List::Cons(2, List::Nil)));

}

This will generate a compilation error, but if we use Box:

enum List {

Cons(i32, Box<List>),

Nil,

}

This adjustment allows the code to compile successfully, making it ideal for structures like trees and linked lists.

2. Transferring Ownership of Large Data:

   When you want to pass large data without duplicating it, Box is beneficial:

fn main() {

let large_data = vec![0; 1_000_000]; // Simulating large data

let boxed_large_data = Box::new(large_data); // Move data into a Box

take_ownership(boxed_large_data); // Ownership is transferred

// boxed_large_data cannot be used here because ownership is moved

}

fn take_ownership(data: Box<Vec<i32>>) {

println!("Data received. Length: {}", data.len());

}

3. Trait Implementation:

   If you want to own a value based on trait implementation rather than a specific type, Box can facilitate this. For example:

fn main() -> Result<(), Box<dyn std::error::Error>> {

let f = std::fs::read("/tmp/not_exist")?;

Ok(())

}

Here, the function can return any error that implements the std::error::Error trait, allowing for flexible error handling.

Rc (Reference Counting)

Rc is a smart pointer that supports multiple owners for the same data. The data remains allocated until the last owner is out of scope. The official Rust documentation illustrates this concept with a TV-watching analogy.

Consider the following example:

use std::rc::Rc;

enum List {

Cons(i32, Rc<List>),

Nil,

}

fn main() {

let four = Rc::new(List::Cons(4, Rc::new(List::Nil)));

let zero_one = List::Cons(0, Rc::new(List::Cons(1, four.clone())));

let two_three = List::Cons(2, Rc::new(List::Cons(3, four.clone())));

}

In this scenario, node four is shared between two paths, showcasing the multiple ownership capability of Rc.

Vector: A Dynamic Array

In Rust, a Vector is an array that can grow or shrink dynamically, similar to a slice. It consists of three key elements: a pointer to the data, its length, and its capacity. Vectors are easy to work with:

fn main() {

let mut v: Vec<i32> = Vec::new();

for i in 0..=10 {

v.push(i);

println!("{:?}", v);

println!("len={:?}", v.len());

println!("capacity={:?}", v.capacity());

}

}

To iterate through a Vector, you can utilize the .iter() method:

fn main() {

let mut v: Vec<i32> = Vec::new();

for i in 0..=10 {

v.push(i);

}

for e in v.iter() {

println!("{:?}", e);

}

}

HashMap: Key-Value Pairs

A HashMap stores pairs of keys and values, functioning similarly to a dictionary in Python. It dynamically adjusts its capacity based on the number of entries. Here’s a basic example of a GPA recording app:

use std::collections::HashMap;

fn main() {

let mut gpa: HashMap<&str, f32> = HashMap::new();

gpa.insert("Jake", 3.0);

gpa.insert("Jon", 2.0);

gpa.insert("Don", 2.7);

gpa.insert("Alice", 3.5);

gpa.insert("Jill", 4.0);

println!("{:?}", gpa);

match gpa.get(&"Alice") {

Some(data) => println!("Alice's GPA = {:?}", data),

None => println!("Alice not found"),

}

}

You can also iterate through a HashMap using the iter() method:

fn main() {

let mut gpa: HashMap<&str, f32> = HashMap::new();

gpa.insert("Jake", 3.0);

gpa.insert("Jon", 2.0);

gpa.insert("Don", 2.7);

gpa.insert("Alice", 3.5);

gpa.insert("Jill", 4.0);

for (name, &score) in gpa.iter() {

println!("{:?}: {:?}", name, score);

}

}

In this article, we have explored several commonly used standard libraries in Rust. Stay tuned for the next post, where we will conclude our exploration of Rust fundamentals by discussing strings and system time.

Thanks for reading!

The first video titled "The Rust Standard Library is SO Confusing...Until Now!" provides insights into overcoming common challenges faced when using Rust's standard library.

The second video, "RustConf 2023 - The standard library is special. Let's change that." discusses the unique aspects of Rust's standard library and potential improvements.