Structs in Rust

# CHAPTER 12

Structs in Rust #

1. Chapter Introduction #

2. Learning Objectives #

• Define and instantiate a standard Struct.

• Access and modify struct fields.

• Implement methods using the impl block.

• Understand the &self parameter in methods.

• Create Associated Functions (similar to static methods/constructors).

3. Defining and Instantiating a Struct #

1. Define the Struct

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

2. Instantiate the Struct

fn main() {
    // To change values later, the ENTIRE struct must be mut
    let mut user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };

    // Access fields using dot notation
    println!("User email: {}", user1.email);

    // Modify a field
    user1.email = String::from("alice_new@example.com");
}

4. Struct Update Syntax #

let user2 = User {
    email: String::from("bob@example.com"),
    username: String::from("bob99"),
    ..user1 // Fills the rest of the fields (active, sign_in_count) from user1
};

5. Adding Methods using the impl Block #

struct Rectangle {
    width: u32,
    height: u32,
}

// Attach methods to Rectangle
impl Rectangle {
    // Method that borrows the instance to read data
    fn area(&self) -> u32 {
        self.width * self.height
    }

    // Method with multiple parameters
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };
    let rect2 = Rectangle { width: 10, height: 40 };

    // Call methods using dot notation
    println!("The area is {} square pixels.", rect1.area());
    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
}

6. Associated Functions (Constructors) #

impl Rectangle {
    // No &self! This is an associated function.
    fn square(size: u32) -> Rectangle {
        Rectangle {
            width: size,
            height: size,
        }
    }
}

fn main() {
    // Call using double colons :: instead of dot notation!
    let sq = Rectangle::square(20); 
}

7. Tuple Structs #

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
    // black and origin have the same data types inside, 
    // but they are fundamentally different Types and cannot be mixed!
}

8. Common Mistakes #

• Partial Mutability: Trying to make one field of a struct mutable while leaving others immutable. Rust does not allow this. If you declare let mut user = User{...}, the *entire* struct is mutable.

• Forgetting & on self: If you write fn area(self), you are taking *ownership* of the struct! Calling .area() will instantly destroy the struct after it returns the area. Almost always use &self (borrowing) for methods.

9. Best Practices #

• Use String over &str in Structs (for now): If you try to store a reference &str inside a struct, the compiler will require you to use "Lifetimes" (which we will learn in Chapter 18). For beginners, always use owned String types inside structs.

10. Exercises #

1. 1. Define a Car struct with make (String), model (String), and year (u32).

1. 2. Write an impl block with an associated function new(make, model, year) that returns a new Car.

1. 3. Write a method print_details(&self) that prints the car's info.

11. MCQs with Answers #

Q1. Does Rust have the class keyword? a) Yes b) No, it uses struct to group data Answer: b) No, it uses struct.

12. Interview Questions #

• Q: How does Rust separate data representation from behavior (logic) compared to traditional Object-Oriented languages?

• Q: Differentiate between a Method and an Associated Function inside an impl block.

13. Summary #

14. Next Chapter Recommendation #