🦀 Rust – Data Structures (Overview): Build with Arrays, Tuples, Vectors, and More

🧲 Introduction – Why Learn Data Structures in Rust?

Data structures are building blocks of real applications. Whether you’re storing configuration, tracking game states, or parsing user input, Rust offers safe and performant data structures like arrays, vectors, tuples, hash maps, enums, and structs—all tightly integrated with the ownership model.

🎯 In this guide, you’ll learn:

• Key built-in data structures in Rust
• How each one is used and declared
• Ownership behavior across data structures
• Quick examples, outputs, and usage scenarios

---

🗂️ 1. Arrays – Fixed-size, Stack-allocated Lists

🔹 Code Example:

fn main() {
    let nums = [1, 2, 3, 4, 5];
    println!("First number: {}", nums[0]);
}

🧠 Highlights:

• Fixed-length ([T; N])
• Stored on stack
• Indexing is bounds-checked (safe)

📤 Output:

First number: 1

---

📦 2. Vectors – Growable, Heap-allocated Lists

🔹 Code Example:

fn main() {
    let mut names = vec!["Alice", "Bob"];
    names.push("Charlie");
    println!("{:?}", names);
}

🧠 Highlights:

• Use vec![] or Vec::new()
• Stored on heap
• Can grow and shrink dynamically

📤 Output:

["Alice", "Bob", "Charlie"]

---

🧊 3. Tuples – Grouping Heterogeneous Values

🔹 Code Example:

fn main() {
    let person = ("Alice", 30);
    println!("{} is {} years old.", person.0, person.1);
}

🧠 Highlights:

• Fixed size
• Elements can be different types
• Indexed with .0, .1, etc.

📤 Output:

Alice is 30 years old.

---

🔢 4. Structs – Custom Data Types

🔹 Code Example:

struct Book {
    title: String,
    pages: u32,
}

fn main() {
    let b = Book {
        title: String::from("Rust Book"),
        pages: 300,
    };

    println!("{} has {} pages.", b.title, b.pages);
}

🧠 Highlights:

• Define your own data types
• Encapsulate related fields
• Works with impl for methods

📤 Output:

Rust Book has 300 pages.

---

🔁 5. Enums – Tagged Unions for Variants

🔹 Code Example:

enum State {
    Loading,
    Loaded,
    Error(String),
}

fn main() {
    let status = State::Error(String::from("404"));

    match status {
        State::Loading => println!("Loading..."),
        State::Loaded => println!("Done!"),
        State::Error(msg) => println!("Error: {}", msg),
    }
}

🧠 Highlights:

• Powerful with match
• Can hold data variants
• Core to Option, Result, etc.

📤 Output:

Error: 404

---

🗃️ 6. HashMap – Key-Value Store

🔹 Code Example:

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert("Alice", 50);
    scores.insert("Bob", 80);

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

🧠 Highlights:

• Use from std::collections
• Key and value must implement Eq and Hash
• Ownership of inserted values is moved

📤 Output (order may vary):

{"Alice": 50, "Bob": 80}

---

🔒 Ownership Rules Across Data Structures

Data Structure	Ownership Behavior
Array	Owns elements; values copied or moved
Vector	Owns heap values; pushing moves values
Tuple	Each element has its own ownership
Struct	Each field is owned; clone() needed if reused
HashMap	Both key and value are moved in by default

---

📌 Summary – Recap & Next Steps

Rust’s built-in data structures are versatile, performant, and fully integrated with its memory safety guarantees. From low-level arrays to high-level hash maps, you can model everything while staying safe and expressive.

🔍 Key Takeaways:

• Use arrays for fixed-size data, vectors for dynamic lists
• tuples are ideal for grouped values, structs for named fields
• enums model variants; hash maps manage key-value data
• All data structures honor ownership and lifetime rules

⚙️ Next: Explore each structure in detail starting with Rust – Arrays.

---

❓FAQs

---

❓ When should I use a vector instead of an array?
✅ Use a vector (Vec<T>) when the size is not known at compile-time or when it can change dynamically.

---

❓ Can I mix types in a vector?
❌ No. Vectors require all elements to be of the same type. Use enums or boxed traits for mixed types.

---

❓ Do data structures copy or move values?
✅ By default, they move values unless they implement the Copy trait. Use .clone() if duplication is needed.

---

❓ How do I iterate over a tuple or struct?
✅ Use destructuring or indexing (.0, .1) for tuples. Use field names for structs.

---

Share Now :