Structs

Introduction

In the world of programming, data structures are fundamental building blocks that help organize and manage data efficiently. One such data structure is the struct (short for structure). A struct allows you to group related pieces of data into a single unit, making your code more organized and readable.

Rust provides robust support for structs, enabling developers to define custom data types with named fields. This tutorial will guide you through defining and using structs in Rust, from basic examples to more advanced use cases.

Concept

A struct in Rust is a composite data type that can group together different types of data under a single name. It's similar to a class in other object-oriented languages but without methods (we'll cover those later). Structs are defined using the struct keyword followed by the struct name and its fields.

Here's the basic syntax for defining a struct:

struct MyStruct {
    field1: Type,
    field2: Type,
    // Add more fields as needed
}

Each field in a struct has a name and a type. You can access these fields using dot notation, similar to other languages.

## Examples

### Basic Struct Definition

Let's start with a simple example of defining a `Point` struct that represents a point in 2D space:

```rust
struct Point {
    x: i32,
    y: i32,
}

In this example, we define a `Point` struct with two fields: `x` and `y`, both of type `i32`.

### Creating Instances

To create an instance of a struct, you can use the following syntax:

```rust
fn main() {
    let origin = Point { x: 0, y: 0 };
    println!("The origin is at ({}, {})", origin.x, origin.y);
}

Here, we create a `Point` instance named `origin` with both `x` and `y` set to `0`. We then print the coordinates of the origin.

### Struct Update Syntax

Rust provides a convenient way to create a new struct instance based on another instance using the **struct update syntax**. This is particularly useful when you want to change only a few fields while keeping others the same:

```rust
fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 3, ..p1 };

    println!("p2.x = {}, p2.y = {}", p2.x, p2.y);
}

In this example, p2 is created by taking all the fields from p1 except for x, which is set to 3.

Tuple Structs

Rust also supports tuple structs, which are similar to regular structs but their fields do not have named identifiers. They behave like tuples:

struct Color(i32, i32, i32);
struct Point3d(f64, f64, f64);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point3d(0.0, 0.0, 0.0);

    println!("Black color: ({}, {}, {})", black.0, black.1, black.2);
    println!("Origin point: ({}, {}, {})", origin.0, origin.1, origin.2);
}

Tuple structs are useful when you want to give a tuple a name but don't need named fields.

Unit-Like Structs

A unit-like struct is a struct without any fields. It's used mainly for defining traits:

struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}

Unit-like structs are useful when you want to implement a trait but don't need to store any data.

What's Next?

Now that you've learned about structs in Rust, the next logical step is to explore enums. Enums (short for enumerations) allow you to define a type by specifying its possible variants. They provide a powerful way to handle different types of related values and are an essential part of Rust's type system.

Stay tuned for our upcoming tutorial on enums!