What are Structs?

In Rust, structs (short for "structures") are a fundamental way to create custom data types. They allow you to group together related values into a single, cohesive unit. Think of them as blueprints for creating objects, bundling multiple pieces of information that describe a single entity.

Structs are similar to classes or objects in other programming languages, but with a focus on data and less on behavior (although structs can have methods).

Defining Structs

To define a struct, you use the struct keyword followed by the struct's name. Inside curly braces {}, you declare the fields of the struct, along with their types.

Syntax:

 struct StructName {
    field_name: DataType,
    another_field: AnotherDataType,
    // ... more fields
} 

Example:

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

In this example, we define a User struct with four fields: username (a String), email (a String), sign_in_count (an unsigned 64-bit integer), and active (a boolean).

Instantiating Structs

Once you've defined a struct, you can create instances of it. This is done by specifying values for each of the struct's fields.

Syntax:

 let instance_name = StructName {
    field_name: value,
    another_field: another_value,
    // ...
}; 

Example:

 let user1 = User {
    email: String::from("someone@example.com"),
    username: String::from("someusername123"),
    active: true,
    sign_in_count: 1,
}; 

In this example, we create an instance of the User struct named user1 and assign values to each of its fields. Note that you need to specify each field by name during instantiation.

Field Init Shorthand

If a variable with the same name as a field is already in scope, you can use the field init shorthand to simplify instantiation:

 let email = String::from("someone@example.com");
let username = String::from("someusername123");

let user2 = User {
    email,
    username,
    active: true,
    sign_in_count: 1,
}; 

Accessing Fields

You can access the fields of a struct instance using dot notation (.).

Example:

 println!("User's email: {}", user1.email);
user1.sign_in_count = user1.sign_in_count + 1;
println!("User's sign-in count: {}", user1.sign_in_count); 

This code first prints the value of the email field of the user1 instance. Then, it increments the sign_in_count field. Note that you can modify fields in a struct if the struct instance is declared as mutable.

Mutable Structs

To modify the fields of a struct instance, you need to declare the instance as mutable using the mut keyword.

Example:

 let mut user1 = User {
    email: String::from("someone@example.com"),
    username: String::from("someusername123"),
    active: true,
    sign_in_count: 1,
};

user1.email = String::from("anotheremail@example.com"); 

Now, the email field can be modified because user1 is declared as mutable.

Ownership and Structs

Structs also adhere to Rust's ownership rules. If a struct contains a field that owns data (like a String), then the struct owns that data. When the struct goes out of scope, the data is dropped.

Example:

 struct Owner {
    name: String,
}

fn main() {
    let owner1 = Owner { name: String::from("Alice") };
    // owner1 owns the string "Alice"

    // When owner1 goes out of scope, the string "Alice" is dropped.
} 

Methods on Structs

You can define methods on structs to add behavior to your custom data types. Methods are similar to functions, but they are associated with a particular struct.

Syntax:

 impl StructName {
    fn method_name(&self, arg1: Type1, arg2: Type2) -> ReturnType {
        // Method body
    }
} 

Example:

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

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }

    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 };
    let rect3 = Rectangle { width: 60, height: 45 };

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2)); // true
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3)); // false
} 

In this example, we define two methods on the Rectangle struct: area, which calculates the area of the rectangle, and can_hold, which determines if one rectangle can fit inside another.

The &self parameter is a reference to the struct instance. It allows the method to access the struct's fields without taking ownership of the struct. There are variations such as `&mut self` for modifying the struct and `self` for taking ownership of the struct.

Associated Functions

You can also define associated functions (often called static methods in other languages) on structs. These functions are associated with the struct itself, not with a specific instance. They are called using the struct name and the :: operator.

Example:

 struct Color {
    red: u8,
    green: u8,
    blue: u8,
}

impl Color {
    fn new(red: u8, green: u8, blue: u8) -> Color {
        Color { red, green, blue }
    }

    fn black() -> Color {
        Color { red: 0, green: 0, blue: 0 }
    }
}

fn main() {
    let red = Color::new(255, 0, 0);
    let black = Color::black();
} 

In this example, new and black are associated functions of the Color struct. new is a common pattern for constructor-like functionality.

Summary

Structs are a powerful way to create custom data types in Rust. They allow you to group related values together, making your code more organized and easier to understand. By using structs and their methods, you can create complex and reusable components.