Сочетания клавиш

Нажмите ← или → для навигации между главами

Нажмите S или / для поиска по книге

Нажмите ?, чтобы показать эту справку

Нажмите Esc, чтобы скрыть эту справку

Определение и создание экземпляров структур

Структуры похожи на кортежи, обсуждавшиеся в разделе «Тип кортеж», тем, что обе содержат несколько связанных значений. Как и кортежи, части структуры могут иметь разные типы. В отличие от кортежей, в структуре вы даёте имя каждой части данных, чтобы было понятно, что означают значения. Добавление этих имён означает, что структуры более гибкие, чем кортежи: вам не нужно полагаться на порядок данных, чтобы указать или получить доступ к значениям экземпляра.

Чтобы определить структуру, мы вводим ключевое слово struct и даём имя всей структуре. Имя структуры должно описывать значение частей данных, которые группируются вместе. Затем внутри фигурных скобок мы определяем имена и типы частей данных, которые мы называем полями. Например, листинг 5-1 показывает структуру, которая хранит информацию об учётной записи пользователя.

Имя файла: src/main.rs
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {}
Листинг 5-1: Определение структуры User

Чтобы использовать структуру после того, как мы её определили, мы создаём экземпляр этой структуры, указывая конкретные значения для каждого из полей. Мы создаём экземпляр, указывая имя структуры и затем добавляя фигурные скобки, содержащие пары ключ: значение, где ключи — это имена полей, а значения — это данные, которые мы хотим сохранить в этих полях. Нам не нужно указывать поля в том же порядке, в котором мы их объявили в структуре. Другими словами, определение структуры — это как общий шаблон для типа, а экземпляры заполняют этот шаблон конкретными данными, создавая значения этого типа. Например, мы можем объявить конкретного пользователя, как показано в листинге 5-2.

Имя файла: src/main.rs
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        active: true,
        username: String::from("someusername123"),
        email: String::from("someone@example.com"),
        sign_in_count: 1,
    };
}
Листинг 5-2: Создание экземпляра структуры User

Чтобы получить конкретное значение из структуры, мы используем точечную нотацию. Например, чтобы получить доступ к адресу электронной почты этого пользователя, мы используем user1.email. Если экземпляр изменяемый, мы можем изменить значение, используя точечную нотацию и присваивая значение конкретному полю. Листинг 5-3 показывает, как изменить значение в поле email изменяемого экземпляра User.

Имя файла: src/main.rs
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

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

    user1.email = String::from("anotheremail@example.com");
}
Листинг 5-3: Изменение значения в поле email экземпляра User

Обратите внимание, что весь экземпляр должен быть изменяемым; Rust не позволяет нам помечать как изменяемые только определённые поля. Как и любое выражение, мы можем создать новый экземпляр структуры как последнее выражение в теле функции, чтобы неявно вернуть этот новый экземпляр.

Листинг 5-4 показывает функцию build_user, которая возвращает экземпляр User с заданными электронной почтой и именем пользователя. Поле active получает значение true, а sign_in_count получает значение 1.

Имя файла: src/main.rs
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn build_user(email: String, username: String) -> User {
    User {
        active: true,
        username: username,
        email: email,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
}
Листинг 5-4: Функция build_user, которая принимает электронную почту и имя пользователя и возвращает экземпляр User

Имеет смысл называть параметры функции так же, как поля структуры, но повторять имена полей email и username и переменные немного утомительно. Если бы у структуры было больше полей, повторение каждого имени стало бы ещё более раздражающим. К счастью, есть удобное сокращение!

Использование сокращения инициализации полей

Поскольку имена параметров и имена полей структуры в листинге 5-4 в точности совпадают, мы можем использовать синтаксис сокращения инициализации полей, чтобы переписать build_user так, чтобы он вёл себя точно так же, но без повторения username и email, как показано в листинге 5-5.

Имя файла: src/main.rs
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn build_user(email: String, username: String) -> User {
    User {
        active: true,
        username,
        email,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
}
Листинг 5-5: Функция build_user, использующая сокращение инициализации полей, поскольку параметры username и email имеют те же имена, что и поля структуры

Здесь мы создаём новый экземпляр структуры User, у которой есть поле с именем email. Мы хотим установить значение поля email в значение параметра email функции build_user. Поскольку поле email и параметр email имеют одинаковое имя, нам нужно написать только email, а не email: email.

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

Часто бывает полезно создать новый экземпляр структуры, который включает большинство значений из другого экземпляра того же типа, но изменяет некоторые из них. Вы можете сделать это с помощью синтаксиса обновления структуры.

Сначала в листинге 5-6 мы показываем, как создать новый экземпляр User в user2 обычным способом, без синтаксиса обновления. Мы устанавливаем новое значение для email, но в остальном используем те же значения из user1, которые мы создали в листинге 5-2.

Имя файла: src/main.rs
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    // --snip--

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

    let user2 = User {
        active: user1.active,
        username: user1.username,
        email: String::from("another@example.com"),
        sign_in_count: user1.sign_in_count,
    };
}
Листинг 5-6: Создание нового экземпляра User с использованием всех, кроме одного, значений из user1

Используя синтаксис обновления структуры, мы можем достичь того же эффекта с меньшим количеством кода, как показано в листинге 5-7. Синтаксис .. указывает, что оставшиеся поля, которые не заданы явно, должны иметь те же значения, что и поля в данном экземпляре.

Имя файла: src/main.rs
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    // --snip--

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

    let user2 = User {
        email: String::from("another@example.com"),
        ..user1
    };
}
Листинг 5-7: Использование синтаксиса обновления структуры для установки нового значения email для экземпляра User, но с использованием остальных значений из user1

Код в листинге 5-7 также создаёт экземпляр в user2, который имеет другое значение для email, но те же значения для полей username, active и sign_in_count из user1. ..user1 должно идти последним, чтобы указать, что любые оставшиеся поля должны получить свои значения из соответствующих полей в user1, но мы можем указать значения для любого количества полей в любом порядке, независимо от порядка полей в определении структуры.

Обратите внимание, что синтаксис обновления структуры использует = как присваивание; это потому, что он перемещает данные, как мы видели в разделе «Взаимодействие переменных и данных при перемещении». В этом примере мы больше не можем использовать user1 после создания user2, потому что String в поле username из user1 был перемещён в user2. Если бы мы дали user2 новые значения String как для email, так и для username, и таким образом использовали бы только значения active и sign_in_count из user1, то user1 всё ещё был бы действителен после создания user2. И active, и sign_in_count — это типы, реализующие трейт Copy, поэтому применялось бы поведение, которое мы обсуждали в разделе «Данные только в стеке: Copy». В этом примере мы также всё ещё можем использовать user1.email, потому что его значение не было перемещено из user1.

Создание разных типов с помощью кортежных структур

Rust также поддерживает структуры, которые выглядят похоже на кортежи, называемые кортежными структурами. Кортежные структуры имеют дополнительное значение, которое обеспечивает имя структуры, но не имеют имён, связанных с их полями; вместо этого у них есть только типы полей. Кортежные структуры полезны, когда вы хотите дать всему кортежу имя и сделать кортеж типом, отличным от других кортежей, и когда именование каждого поля, как в обычной структуре, было бы многословным или избыточным.

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

Имя файла: src/main.rs
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
}

Обратите внимание, что значения black и origin имеют разные типы, потому что они являются экземплярами разных кортежных структур. Каждая структура, которую вы определяете, является своим собственным типом, даже если поля внутри структуры могут иметь одинаковые типы. Например, функция, которая принимает параметр типа Color, не может принять Point в качестве аргумента, даже если оба типа состоят из трёх значений i32. В остальном экземпляры кортежных структур похожи на кортежи тем, что вы можете деструктурировать их на отдельные части, и вы можете использовать ., за которым следует индекс, для доступа к отдельному значению. В отличие от кортежей, кортежные структуры требуют, чтобы вы указали тип структуры при их деструктурировании. Например, мы бы написали let Point(x, y, z) = origin;, чтобы деструктурировать значения в origin в переменные с именами x, y и z.

Определение unit-подобных структур

Вы также можете определять структуры, у которых вообще нет полей! Они называются unit-подобными структурами, потому что ведут себя подобно (), unit-типу, который мы упоминали в разделе «Тип кортеж». Unit-подобные структуры могут быть полезны, когда вам нужно реализовать трейт для некоторого типа, но у вас нет данных, которые вы хотите хранить в самом типе. Мы обсудим трейты в главе 10. Вот пример объявления и создания экземпляра unit-структуры с именем AlwaysEqual:

Имя файла: src/main.rs
struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}

Чтобы определить AlwaysEqual, мы используем ключевое слово struct, нужное нам имя, а затем точку с запятой. Не нужны ни фигурные скобки, ни круглые скобки! Затем мы можем получить экземпляр AlwaysEqual в переменной subject аналогичным образом: используя определённое нами имя, без каких-либо фигурных скобок или круглых скобок. Представьте, что позже мы реализуем поведение для этого типа так, чтобы каждый экземпляр AlwaysEqual всегда был равен любому экземпляру любого другого типа, возможно, чтобы иметь известный результат для целей тестирования. Нам не понадобились бы никакие данные для реализации этого поведения! В главе 10 вы увидите, как определять трейты и реализовывать их для любого типа, включая unit-подобные структуры.

Владение данными структуры

В определении структуры User в листинге 5-1 мы использовали владеющий тип String, а не тип среза строки &str. Это осознанный выбор, потому что мы хотим, чтобы каждый экземпляр этой структуры владел всеми своими данными и чтобы эти данные были действительны до тех пор, пока действительна вся структура.

Также возможно, чтобы структуры хранили ссылки на данные, принадлежащие чему-то другому, но для этого требуется использование времён жизни, функции Rust, которую мы обсудим в главе 10. Времена жизни гарантируют, что данные, на которые ссылается структура, действительны до тех пор, пока действительна структура. Допустим, вы пытаетесь сохранить ссылку в структуре, не указывая времена жизни, как в следующем примере в src/main.rs; это не сработает:

Имя файла: src/main.rs
struct User {
    active: bool,
    username: &str,
    email: &str,
    sign_in_count: u64,
}

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

Компилятор пожалуется, что ему нужны спецификаторы времени жизни:

$ cargo run
   Compiling structs v0.1.0 (file:///projects/structs)
error[E0106]: missing lifetime specifier
 --> src/main.rs:3:15
  |
3 |     username: &str,
  |               ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct User<'a> {
2 |     active: bool,
3 ~     username: &'a str,
  |

error[E0106]: missing lifetime specifier
 --> src/main.rs:4:12
  |
4 |     email: &str,
  |            ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct User<'a> {
2 |     active: bool,
3 |     username: &str,
4 ~     email: &'a str,
  |

For more information about this error, try `rustc --explain E0106`.
error: could not compile `structs` (bin "structs") due to 2 previous errors

В главе 10 мы обсудим, как исправить эти ошибки, чтобы вы могли хранить ссылки в структурах, но пока мы будем исправлять подобные ошибки, используя владеющие типы, такие как String, вместо ссылок, таких как &str.