Глава 7: Структуры и перечисления в Rust

1.1. Именованные структуры

Именованные структуры — это как карточка с подписанными полями. У каждого поля есть имя и значение, к которым можно обращаться по имени.

struct Person {
    name: String,  // поле "name" — это имя человека, тип String
    age: u32,      // поле "age" — возраст, тип u32 (число без знака)
    height: f32    // поле "height" — рост, тип f32 (число с плавающей точкой)
    active: bool,
}

fn main() {
    let person = Person {
        name: String::from("Alice"),
        age: 30,
        active: true,
    };
    println!("{} is {} years old", person.name, person.age);
}

Тонкость: Поля структуры по умолчанию приватны вне модуля. Используйте pub для публичного доступа.

Person — это название структуры, а внутри фигурных скобок {} перечислены поля с их именами (name, age, height) и типами данных (String, u32, f32). Каждое поле — это как отдельная характеристика, и ты можешь обращаться к ним по имени.

Теперь, чтобы создать конкретного человека(Alice), ты используешь эту структуру. А если хочешь достать, например, возраст, пишешь: println!("Возраст: {}", person.age); // выведет "Возраст: 30"

1.2. Кортежные структуры

struct Point(i32, i32, i32);

fn main() {
    let point = Point(1, 2, 3);
    println!("x: {}, y: {}, z: {}", point.0, point.1, point.2);
}

Совет: Используйте кортежные структуры для небольших данных, например координат.

Кортежные структуры — это как список без подписей. Поля не имеют имён, только порядок, и к ним обращаются по номерам.

Пример: точка в пространстве с координатами x, y, z.

struct Point(f32, f32, f32);

Создаём точку:

let point = Point(1.0, 2.5, 3.7);

Достаём координаты:

println!("X: {}", point.0); // выведет "X: 1.0"
println!("Y: {}", point.1); // выведет "Y: 2.5"
println!("Z: {}", point.2); // выведет "Z: 3.7"

Плюс: проще и короче, если имена не нужны, а порядок понятен.

В чём разница?

• Именованные: обращаемся по именам (person.name).
• Кортежные: обращаемся по индексам (point.0).

1.3. Юнит-структуры

Юнит-структуры не содержат полей. Они объявляются просто с именем и без фигурных скобок или с пустыми фигурными скобками.

struct Unit;
struct UnitStruct {} // Или так

fn main() {
    let unit = Unit;
}

Примечание: Занимают нулевой размер в памяти.

Почему они "пустые" и зачем нужны?

Юнит-структуры не содержат данных, но это не значит, что они бесполезны. Их смысл заключается в том, чтобы представлять типы или маркеры, которые используются для передачи информации о структуре программы или её логике на уровне типов, а не для хранения данных.

Вот несколько основных случаев, когда юнит-структуры полезны:

Маркерные типы (Marker Types)

Юнит-структуры часто используются как "пустые" типы для обозначения какого-то состояния, поведения или роли в программе. Например, они могут служить индикаторами в системе типов:

struct Admin;
struct User;

fn check_access(_: Admin) {
    println!("Доступ разрешён");
}

fn main() {
    let admin = Admin;
    check_access(admin); // Работает
    // let user = User;
    // check_access(user); // Ошибка компиляции!
}

Здесь Admin и User — юнит-структуры, которые не содержат данных, но позволяют компилятору различать роли через типы.

Реализация трейтов без данных

Иногда нужно реализовать трейт (интерфейс) для типа, который не требует хранения данных. Юнит-структуры идеально подходят для этого:

struct Empty;

impl std::fmt::Display for Empty {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "Я пустая структура!")
    }
}

fn main() {
    let e = Empty;
    println!("{}", e); // Вывод: "Я пустая структура!"
}

Здесь Empty не хранит данных, но реализует трейт Display.

Плейсхолдеры или заглушки

Юнит-структуры могут использоваться как временные заменители в коде, если вы планируете добавить поля позже, но пока хотите протестировать логику.

Нулевой размер (Zero-sized types)

В Rust юнит-структуры имеют размер 0 байт в памяти (zero-sized type, ZST). Это значит, что они не занимают места во время выполнения программы, что полезно для оптимизации. Компилятор может полностью убрать их из итогового кода, если они не используются напрямую.

struct Nothing;

fn main() {
    let n = Nothing;
    println!("Размер Nothing: {}", std::mem::size_of::<Nothing>()); // Вывод: 0
}

Семантика "единичного значения"

Юнит-структуры похожи на тип () (unit type) в Rust, который тоже "пустой" и используется как значение по умолчанию для функций, не возвращающих ничего полезного. Юнит-структуры можно рассматривать как именованные версии (), чтобы сделать код более читаемым.

Зачем они вообще, если нет полей?

Их ценность не в хранении данных, а в предоставлении семантики и структуры кода. Они помогают:

• Разделять логику через типы.
• Использовать систему типов Rust для предотвращения ошибок на этапе компиляции.
• Делать код более выразительным и самодокументируемым.

Например, вместо того чтобы использовать булевы флаги вроде is_admin: bool, можно ввести юнит-структуры Admin и User, чтобы компилятор сам следил за корректностью логики.

1.4. Обновление структуры

Создавайте новый экземпляр, копируя часть полей с помощью ...

fn main() {
    let person1 = Person {
        name: String::from("Alice"),
        age: 30,
        active: true,
    };
    let person2 = Person {
        name: String::from("Bob"),
        ..person1
    };
    println!("{} is {}", person2.name, person2.age); // Bob is 30
}

• Создаётся person1 — экземпляр структуры Person с полями: name = "Alice", age = 30, active = true.
• Создаётся person2 — другой экземпляр Person, где name = "Bob", а остальные поля копируются из person1 через ..person1.
• Выводится строка "Bob is 30" с помощью println!, подставляя person2.name и person2.age.

2.1. Определение методов

Методы — это специальные функции, которые "привязаны" к структурам или перечислениям и позволяют им "действовать". Если структура — это как коробка с данными, то методы — это инструкции, которые говорят, что с этими данными можно сделать: например, посчитать, изменить или вывести их. Методы добавляются через блок impl (сокращение от "implementation" — реализация), где мы определяем, как именно структура или перечисление будет себя вести.

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 };
    println!("Area: {}", rect1.area()); // Area: 1500
    println!("Can hold: {}", rect1.can_hold(&rect2)); // Can hold: true
}

В Rust impl (сокращение от "implementation") — это конструкция, которая позволяет определить методы и поведение для структуры (или другого типа данных).

После указания impl Rectangle мы можем добавить функции (методы), которые будут доступны для всех экземпляров Rectangle, например, area и can_hold.

Это похоже на добавление "возможностей" объекту: без impl структура — просто набор данных, а с impl она обретает функциональность.

Внутри impl используется &self, чтобы метод мог обращаться к полям текущего экземпляра структуры, не передавая его явно как аргумент.

Пояснения к коду:

• Определяется структура Rectangle с полями: width: u32 (ширина) и height: u32 (высота), оба типа u32 (32-битное беззнаковое число).
• Используется ключевое слово impl Rectangle — это блок реализации (implementation), который добавляет методы к структуре Rectangle, позволяя ей иметь собственное поведение:
  • area(&self) -> u32 — метод, вычисляющий площадь, возвращает произведение self.width * self.height, где &self — ссылка на текущий экземпляр структуры.
  • can_hold(&self, other: &Rectangle) -> bool — метод, проверяющий, может ли текущий прямоугольник вместить другой, сравнивая их ширину и высоту (self.width >= other.width && self.height >= other.height), принимает ссылку на другой Rectangle как аргумент.
• В функции main:
  • Создаётся rect1 с width = 30, height = 50.
  • Создаётся rect2 с width = 10, height = 40.
  • Выводится площадь rect1 через rect1.area() — "Area: 1500".
  • Проверяется, может ли rect1 вместить rect2 через rect1.can_hold(&rect2), выводится "Can hold: true".

2.2. Ассоциированные функции

Вызываются через :: и не требуют экземпляра.

Ассоциированные функции в Rust — это функции, определённые в блоке impl, которые не принимают &self в качестве аргумента, то есть не привязаны к конкретному экземпляру структуры.

Они вызываются через синтаксис :: (например, Rectangle::square), а не через точку (.), как методы.

Обычно используются как конструкторы (например, для создания нового экземпляра структуры) или для других операций, не требующих доступа к данным экземпляра.

В примере ниже square — это удобный способ создать квадрат, задав только одну сторону.

impl Rectangle {
    fn square(size: u32) -> Rectangle {
        Rectangle { width: size, height: size }
    }
}

fn main() {
    let sq = Rectangle::square(5);
    println!("Square area: {}", sq.area()); // Square area: 25
}

• Используется блок impl Rectangle — это реализация для структуры Rectangle (предполагается, что она определена где-то выше, например, как struct Rectangle { width: u32, height: u32 }):
  • fn square(size: u32) -> Rectangle — это ассоциированная функция, которая вызывается через :: (например, Rectangle::square) и не требует экземпляра структуры. Она принимает size: u32 и возвращает новый Rectangle с width = size и height = size.
• В функции main:
  • Создаётся переменная sq с помощью ассоциированной функции Rectangle::square(5), которая возвращает квадрат со сторонами 5 (ширина = 5, высота = 5).
  • Выводится площадь квадрата через метод sq.area() (предполагается, что он определён ранее, например, как self.width * self.height), результат — "Square area: 25".

Определение перечислений

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

fn main() {
    let dir = Direction::Up;
}

Перечисления с данными

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {
    let msg = Message::Write(String::from("Hello"));
}