They serve very different purposes but are used together when handing database queries.
Struct (Structure)
- Purpose: To create a custom data type that groups together related data fields. Think of it as defining a blueprint or a template for a specific kind of object or record.
- Fields: Can hold multiple fields (members).
- Field Types: Each field within a struct can have a different data type.
- Size/Structure: The structure (number and types of fields) is fixed at compile time. Once you define a struct, all instances of that struct will have the exact same fields.
- Access: You access fields by their name using dot notation (.).
- Analogy: Like defining the columns of a single row in a database table (e.g., a User has an id, a username, an email). Or like defining a form with specific named boxes to fill in.
- Memory: Fields are typically stored together in memory (potentially with some padding for alignment). The total size is known at compile time (if all fields have sizes known at compile time).
Example:
// Define a blueprint for a 'Point'
struct Point {
x: f64, // Field 'x' is a 64-bit float
y: f64, // Field 'y' is also a 64-bit float
}
// Define a blueprint for a 'User'
struct User {
id: u32, // Field 'id' is an unsigned 32-bit integer
username: String, // Field 'username' is a String
is_active: bool, // Field 'is_active' is a boolean
}
fn main() {
// Create an instance of the Point struct
let p1 = Point { x: 10.0, y: 5.5 };
// Create an instance of the User struct
let user1 = User {
id: 101,
username: String::from("alice"),
is_active: true,
};
// Access fields by name using dot notation
println!("Point coordinates: ({}, {})", p1.x, p1.y);
println!("User ID: {}, Name: {}", user1.id, user1.username);
// You CANNOT add new fields to p1 or user1 at runtime.
// You CANNOT store different types in the *same* field (x is always f64).
}Vec (Vector)
- Purpose: To store a variable-length sequence (list) of items. It’s a growable array provided by the Rust standard library.
- Elements: Holds multiple elements.
- Element Types: All elements within a Vec must have the exact same data type.
- Size/Structure: The number of elements is variable at runtime. You can add (push), remove (pop, remove), and clear elements.
- Access: You access elements by their numerical index (position starting from 0) using square bracket notation ([]).
- Analogy: Like a shopping list where all items are listed one after another. Or like a single column in a spreadsheet containing multiple values of the same type (e.g., a list of just user IDs, or a list of just usernames).
- Memory: Stores its elements contiguously in a block of memory allocated on the heap. It also stores its current length and capacity.
Example:
fn main() {
// Create an empty vector that will hold signed 32-bit integers
let mut numbers: Vec<i32> = Vec::new();
// Create a vector with initial elements using the vec! macro
let mut names: Vec<String> = vec![String::from("Alice"), String::from("Bob")];
// Add elements
numbers.push(10);
numbers.push(20);
numbers.push(30);
names.push(String::from("Charlie"));
// Access elements by index (panics if index is out of bounds)
println!("First number: {}", numbers[0]); // Output: 10
println!("Second name: {}", names[1]); // Output: Bob
// Get the current length
println!("Number of numbers: {}", numbers.len()); // Output: 3
println!("Number of names: {}", names.len()); // Output: 3
// You CANNOT store different types in the same vector
// numbers.push("hello"); // Compile-time error! Expected i32, found &str
// Iterate over elements
for name in &names {
println!("Name: {}", name);
}
}Summary Table:
| Feature | struct | Vec<T> |
|---|---|---|
| Purpose | Define a custom type with fixed fields | Store a variable-length list of elements |
| Members | Fields | Elements |
| Member Types | Can be different | Must be the same (T) |
| Size | Fixed number of fields (compile-time) | Variable number of elements (runtime) |
| Access | By name (.field_name) | By index ([index]) |
| Mutability | Structure is fixed | Length can change |
| Analogy | Record, Form Template, Row Definition | List, Column Data, Growable Array |
Combining Them (Very Common!)
You often use structs inside vectors, especially when dealing with database results:
struct User {
id: u32,
username: String,
}
fn main() {
// A vector where EACH element is a User struct
let mut users: Vec<User> = Vec::new();
users.push(User { id: 1, username: String::from("dave") });
users.push(User { id: 2, username: String::from("eva") });
// Access the first user (a User struct)
let first_user = &users[0];
// Access a field of the struct within the vector
println!("First user's ID: {}", first_user.id); // Output: 1
println!("First user's Name: {}", users[0].username); // Can chain access
// Add another user
users.push(User { id: 3, username: String::from("frank") });
println!("Total users: {}", users.len()); // Output: 3
}This Vec<User> pattern perfectly represents fetching multiple rows from a database, where each row matches the User struct’s definition.