Создание и использование структур в Rust: Полное руководство

Структура (или struct) в Rust — это пользовательский тип данных, который позволяет группировать связанные данные вместе. Структуры похожи на классы в других языках программирования, но в Rust (как говорит документация) они более гибкие и мощные, так как язык предоставляет различные возможности для работы с ними. Кто бы сомневался 😁 При этом видов структур существует несколько.

В этой главе мы подробно рассмотрим как классические C-структуры, так и структуры-кортежи, юнит-структуры, а также способы работы с ними.

Шаг 1. Проектирование структуры
#

Прежде чем писать код, важно спроектировать и описать, что мы хотим получить. Давайте возьмем нашу любимую тему по системам для управления умным домом. В нашей системе есть хаб (центральное устройство) и несколько сенсоров, которые подключены к этому хабу.

Диаграмма классов
#

classDiagram
    class HUB {
        +String name
        +String id
        +String location
        +Vec~Sensor~ sensors
    }

    class Sensor {
        +String name
        +String id
        +String type
        +f32 value
        +String unit
        +bool isActive
    }

    HUB "1" --> "n" Sensor : хаб хранит сенсоры

Описание структур и полей:
#

Hub:
- name: String — имя хаба.
- id: String — уникальный идентификатор хаба.
- location: String — местоположение хаба.
- sensors: Vec<Sensor> — список сенсоров, подключенных к хабу.
Sensor:
- name: String — имя сенсора.
- id: String — уникальный идентификатор сенсора.
- sensor_type: String — тип сенсора (например, “температура”, “влажность” и т.д.).
- value: f32 — текущее значение, измеренное сенсором.
- unit: String — единица измерения (например, “°C”, “%” и т.д.).
- is_active: bool — статус сенсора (активен/неактивен).

Шаг 2. Разновидности структур и синтаксис инициализации
#

Rust поддерживает три основных вида структур:

Структуры с именованными полями (классические C-структуры).
Структуры-кортежи (Tuple Structs).
Юнит-структуры (Unit-like Structs).

Давайте изучим все виды структур, сокращенную инициализацию, синтаксис перехода (..) и правила видимости полей на интерактивных слайдах ниже:

Структуры в Rust

Шаг 1/6

 1#[allow(dead_code)]
 2#[derive(Debug)]
 3struct Hub {
 4    name: String,
 5    id: String,
 6    location: String,
 7    sensors: Vec<Sensor>,
 8}
 9
10#[allow(dead_code)]
11#[derive(Debug)]
12struct Sensor {
13    name: String,
14    id: String,
15    sensor_type: String,
16    value: f32,
17    unit: String,
18    is_active: bool,
19}
20
21fn main() {
22    let hub = Hub {
23        name: "Main Hub".to_string(),
24        id: String::from("HUB001"),
25        location: "Room 101".to_string(),
26        sensors: Vec::new(), // пустой список сенсоров
27    };
28
29    println!("{:#?}", hub);
30}

Объявление и базовая инициализация структур

Структуры определяются с помощью ключевого слова struct.
Атрибут #[derive(Debug)] позволяет выводить структуру в отладочном формате с помощью {:#?}.

Результат выполнения:

 1#[allow(dead_code)]
 2#[derive(Debug)]
 3struct Hub {
 4    name: String,
 5    id: String,
 6    location: String,
 7    sensors: Vec<Sensor>,
 8}
 9
10#[allow(dead_code)]
11#[derive(Debug)]
12struct Sensor {
13    name: String,
14    id: String,
15    sensor_type: String,
16    value: f32,
17    unit: String,
18    is_active: bool,
19}
20
21fn main() {
22    let sensor1 = Sensor {
23        name: "Temperature Sensor".to_string(),
24        id: "TEMP001".to_string(),
25        sensor_type: "Temperature".to_string(),
26        value: 25.3,
27        unit: "°C".to_string(),
28        is_active: true,
29    };
30
31    let sensor2 = Sensor {
32        name: "Humidity Sensor".to_string(),
33        id: "HUM001".to_string(),
34        sensor_type: "Humidity".to_string(),
35        value: 60.5,
36        unit: "%".to_string(),
37        is_active: true,
38    };
39
40    let hub = Hub {
41        name: "Main Hub".to_string(),
42        id: String::from("HUB001"),
43        location: "Room 101".to_string(),
44        sensors: vec![sensor1, sensor2],
45    };
46
47    println!("{:#?}", hub);
48}

Структуры со вложенными коллекциями

Мы создали экземпляры Sensor и передали их в поле sensors структуры Hub.
Макрос vec! используется для удобной инициализации вектора Vec<Sensor>.

Результат выполнения:

 1#[derive(Debug, Default)]
 2struct Foo {
 3    a: u32,
 4    b: u8,
 5}
 6
 7fn main() {
 8    let a = 42;
 9    let b = 13;
10
11    // Сокращенный синтаксис инициализации (field init shorthand)
12    // Имена переменных совпадают с именами полей
13    let x = Foo { a, b };
14
15    // Синтаксис перехода (struct update syntax ..)
16    // Копирование (перенос) значений оставшихся полей из другой структуры
17    let y = Foo { a: 50, ..x };
18
19    // Инициализация структуры с дефолтными значениями, кроме поля a
20    let z = Foo { a: 100, ..Default::default() };
21
22    println!("x: {:?}", x);
23    println!("y: {:?}", y);
24    println!("z: {:?}", z);
25}

Сокращенный синтаксис и синтаксис перехода

Если имена переменных совпадают с именами полей, можно писать a вместо a: a (field init shorthand).
Синтаксис .. позволяет скопировать остальные поля из другого экземпляра той же структуры.
Типаж Default позволяет инициализировать поля по умолчанию с помощью ..Default::default().

Результат выполнения:

 1// Объявление структуры-кортежа
 2#[derive(Debug)]
 3struct Bar(u32, bool);
 4
 5fn main() {
 6    // Создание экземпляра
 7    let x = Bar(42, true);
 8
 9    // Доступ к полям по порядковому индексу
10    let number = x.0;
11    let flag = x.1;
12
13    println!("x: {:?}", x);
14    println!("Поля: number = {}, flag = {}", number, flag);
15
16    // Неявное представление конструктора структуры-кортежа как функции
17    let constructor: fn(u32, bool) -> Bar = Bar;
18    let y = constructor(100, false);
19    println!("y: {:?}", y);
20}

Структуры-кортежи (Tuple Structs)

Поля в структурах-кортежах не имеют названий, а определяются только своими типами.
Доступ к полям осуществляется по порядковому индексу через точку: x.0, x.1.
Имя структуры-кортежа выступает в роли функции-конструктора (например, Bar имеет тип fn(u32, bool) -> Bar).

Результат выполнения:

 1// Объявление юнит-структуры
 2#[derive(Debug)]
 3struct Baz;
 4
 5fn main() {
 6    // Корректное создание (без использования скобок)
 7    let x = Baz;
 8
 9    println!("x: {:?}", x);
10}

Юнит-структуры (Unit-like Structs)

Объявляются вообще без использования скобок.
Создаются также без использования скобок: let x = Baz;.
Обычно используются как маркеры или для реализации типажей на них без хранения данных.

Результат выполнения:

 1// Структура с полями разного уровня видимости
 2#[allow(dead_code)]
 3pub struct VisibleStruct {
 4    pub a: u32,          // Публичное поле (доступно везде)
 5    pub(crate) b: u8,    // Доступно только внутри текущего крейта
 6    c: u64,              // Приватное поле (доступно только внутри текущего модуля)
 7}
 8
 9fn main() {
10    let x = VisibleStruct { a: 1, b: 2, c: 3 };
11    println!("a = {}, b = {}", x.a, x.b);
12    // Доступ к x.c разрешен, так как main находится в том же модуле
13    println!("c = {}", x.c);
14}

Управление видимостью полей

Поля структур приватны по умолчанию.
Модификатор pub делает поле видимым извне текущего модуля и крейта.
Модификатор pub(crate) делает поле видимым только внутри текущего крейта.

Результат выполнения:

Детали реализации и шаги:
#

Шаг 1. Определение и базовая инициализация:
- Мы определили классические структуры с именованными полями Hub и Sensor.
- Инициализировали экземпляр структуры Hub с пустым вектором sensors (Vec::new()).
Шаг 2. Структуры со вложенными коллекциями:
- Мы создали два сенсора и проинициализировали структуру Hub, передав сенсоры во вложенный массив с помощью макроса vec!.
Шаг 3. Сокращенный синтаксис и синтаксис перехода:
- Field Init Shorthand: Если имена переменных совпадают с именами полей структуры, мы можем просто указать имя переменной (например, let x = Foo { a, b };).
- Struct Update Syntax: С помощью .. мы можем скопировать или перенести значения оставшихся полей из другого экземпляра структуры (например, let y = Foo { a: 50, ..x };).
Шаг 4. Структуры-кортежи (Tuple Structs):
- Именованный тип, поля которого не имеют названий, а определяются только типами в круглых скобках: struct Bar(u32, bool);.
- Доступ к полям осуществляется по порядковому индексу: x.0, x.1.
- Тип структуры-кортежа является функцией-конструктором: let constructor: fn(u32, bool) -> Bar = Bar;.
- Часто используется для паттерна Newtype (создание безопасной обертки вокруг одного типа).
Шаг 5. Юнит-структуры (Unit-like Structs):
- Объявляются с помощью ключевого слова struct вообще без использования скобок: struct Baz;.
- Создаются аналогично без скобок: let x = Baz;.
Шаг 6. Видимость и управление доступом к полям:
- По умолчанию все поля приватны (доступны только внутри текущего модуля).
- Модификаторы видимости управляют доступом:
  - pub — поле публично везде.
  - pub(crate) — поле видимо только внутри текущего крейта.
  - pub(super) — поле видимо только родительскому модулю.

Примечание по видимости: Даже если поле структуры помечено как pub, сама структура должна быть доступна (публична) внешнему коду, чтобы поля можно было прочитать.