Structs

Defining Structs

A struct groups related fields under a single named type. Each field has a name and a type.

struct Point {
    x: f64,
    y: f64,
}

You create an instance by providing values for every field.

let p = Point { x: 3.0, y: 4.0 };

Field Access

Access fields with dot notation: p.x, p.y. Fields are private to the module by default; prefix them with pub to expose them.

Struct Update Syntax

When you want a new instance that shares most fields with an existing one, use the .. update syntax:

let p2 = Point { x: 10.0, ..p };

This copies the remaining fields (y in this case) from p. Note that fields implementing Copy are copied; fields that are Move-only are moved.

Methods

Add behaviour to a struct in an impl block. Each method takes the receiver as its first parameter.

🦀 Methods take self, &self, or &mut self

• self — the method takes ownership of the instance (consuming it).
• &self — the method borrows the instance immutably; it can read fields but not change them.
• &mut self — the method borrows the instance mutably; it can read and modify fields.

Most methods use &self (read-only) or &mut self (read-write). Use self only when you intentionally want to consume the value, such as in a builder pattern.

impl Point {
    fn distance_from_origin(&self) -> f64 {
        (self.x * self.x + self.y * self.y).sqrt()
    }
}

Associated Functions (the new Pattern)

Functions inside impl that do not take a self parameter are called associated functions. They are called with :: syntax. The conventional name for a constructor is new:

impl Point {
    fn new(x: f64, y: f64) -> Self {
        Point { x, y }
    }
}

let p = Point::new(1.0, 2.0);

Self inside an impl block is an alias for the type being implemented.

Tuple Structs

Tuple structs give a name to an unnamed sequence of fields. They are useful as lightweight type-safe wrappers.

struct Color(u8, u8, u8);

let red = Color(255, 0, 0);
println!("{}", red.0); // access by index

Unlike a plain tuple, a Color and a Point with the same field types are distinct types — the compiler will reject mixing them up.

Run ▸ Open in Rust Playground

#[derive(Debug)]
struct Rectangle {
    width: f64,
    height: f64,
}

impl Rectangle {
    fn new(width: f64, height: f64) -> Self {
        Rectangle { width, height }
    }

    fn area(&self) -> f64 {
        self.width * self.height
    }

    fn perimeter(&self) -> f64 {
        2.0 * (self.width + self.height)
    }

    fn is_square(&self) -> bool {
        self.width == self.height
    }
}

struct Color(u8, u8, u8);

fn main() {
    let rect = Rectangle::new(5.0, 3.0);
    println!("Rectangle: {:?}", rect);
    println!("Area: {}", rect.area());
    println!("Perimeter: {}", rect.perimeter());
    println!("Is square: {}", rect.is_square());

    let square = Rectangle::new(4.0, 4.0);
    println!("Is square: {}", square.is_square());

    let red = Color(255, 0, 0);
    println!("Red: ({}, {}, {})", red.0, red.1, red.2);
}

Which receiver type should you use for a method that only needs to read struct fields?

self &self &mut self Self

How do you call an associated function named new on a struct called Rectangle?

Rectangle.new() Rectangle->new() Rectangle::new() new Rectangle()

What distinguishes a tuple struct from a plain tuple?

Tuple structs can only hold primitive types. Tuple structs are always public. A tuple struct is a distinct named type, so two tuple structs with the same field types are not interchangeable. Tuple structs cannot derive Debug.

Submit

Mark as complete