Файл: Язык программирования Rust.pdf

Скачать файл (7,02Мб)

Заказать решение

ВУЗ: Не указан

Категория: Не указан

Дисциплина: Не указана

Добавлен: 11.01.2024

Просмотров: 1167

Скачиваний: 5

ВНИМАНИЕ! Если данный файл нарушает Ваши авторские права, то обязательно сообщите нам.

СОДЕРЖАНИЕ

Недействительные ссылкиВ языках с указателями легко ошибочно создать висячий указатель — указатель,ссылающийся на место в памяти, которое могло быть передано кому-то другому после освобождения этой части памяти, сохраняя при этом указатель на неё. В Rust, напротив,компилятор гарантирует, что ссылки никогда не будут висячими: если у вас есть ссылка на какие-то данные, компилятор убедится, что данные не выйдут за пределы области видимости до того, как это сделает ссылка на них.Давайте попробуем создать висячую ссылку, чтобы увидеть, как Rust предотвращает их появление с помощью ошибки во время компиляции:Файл: src/main.rsЗдесь ошибка:Это сообщение об ошибке относится к особенности языка, которую мы ещё не рассмотрели: времени жизни. Мы подробно обсудим времена жизни в главе 10. Но если вы не обращаете внимания на части, касающиеся времени жизни, сообщение будет содержать ключ к тому, почему этот код является проблемой:fn main() { let reference_to_nothing = dangle(); } fn dangle() -> &String { let s = String::from("hello"); &s } $ cargo run Compiling ownership v0.1.0 (file:///projects/ownership) error[E0106]: missing lifetime specifier --> src/main.rs:5:16 | 5 | fn dangle() -> &String { | ^ expected named lifetime parameter | = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from help: consider using the `'static` lifetime | 5 | fn dangle() -> &'static String { |

Определение и инициализация структурСтруктуры похожи на кортежи, рассмотренные в разделе "Кортежи", так как оба хранят несколько связанных значений. Как и кортежи, части структур могут быть разных типов.В отличие от кортежей, в структуре необходимо именовать каждую часть данных для понимания смысла значений. Добавление этих имён обеспечивает большую гибкость структур по сравнению с кортежами: не нужно полагаться на порядок данных для указания значений экземпляра или доступа к ним.Для определения структуры указывается ключевое слово struct и её название.Название должно описывать значение частей данных, сгруппированных вместе. Далее, в фигурных скобках для каждой новой части данных поочерёдно определяются имя части данных и её тип. Каждая пара имя: тип называется полем. Листинг 5-1 описывает структуру для хранения информации об учётной записи пользователя:Листинг 5-1: Определение структуры UserПосле определения структуры можно создавать её экземпляр, назначая определённое значение каждому полю с соответствующим типом данных. Чтобы создать экземпляр, мы указываем имя структуры, затем добавляем фигурные скобки и включаем в них пары ключ: значение (key: value), где ключами являются имена полей, а значениями являются данные, которые мы хотим сохранить в полях. Нет необходимости чётко следовать порядку объявления полей в описании структуры (но всё-таки желательно для удобства чтения). Другими словами, объявление структуры - это как шаблон нашего типа, в то время как экземпляр структуры использует этот шаблон, заполняя его определёнными данными, для создания значений нашего типа. Например, можно объявить пользователя как в листинге 5-2:Листинг 5-2: Создание экземпляра структуры UserЧтобы получить конкретное значение из структуры, мы используем запись через точку.Например, чтобы получить доступ к адресу электронной почты этого пользователя, мы structUser { active: bool, username: String, email: String, sign_in_count: u64, } fn main() { let user1 = User { email: String::from("someone@example.com"), username: String::from("someusername123"), active: true, sign_in_count: 1, }; } используем user1.email. Если экземпляр является изменяемым, мы можем поменять значение, используя точечную нотацию и присвоение к конкретному полю. В Листинге5-3 показано, как изменить значение в поле email изменяемого экземпляра UserЛистинг 5-3: Изменение значения в поле email экземпляра UserЗаметим, что весь экземпляр структуры должен быть изменяемым; Rust не позволяет помечать изменяемыми отдельные поля. Как и для любого другого выражения, мы можем использовать выражение создания структуры в качестве последнего выражения тела функции для неявного возврата нового экземпляра.На листинге 5-4 функция build_user возвращает экземпляр User с указанным адресом и именем. Поле active получает значение true, а поле sign_in_count получает значение1Листинг 5-4: Функция build_user, которая принимает email и имя пользователя и возвращает экземпляр UserИмеет смысл называть параметры функции теми же именами, что и поля структуры, но необходимость повторять email и username для названий полей и переменных несколько утомительна. Если структура имеет много полей, повторение каждого имени станет ещё более раздражающим. К счастью, есть удобное сокращение!Использование сокращённой инициализации поляТак как имена входных параметров функции и полей структуры являются полностью идентичными в листинге 5-4, возможно использовать синтаксис сокращённойfn main() { let mut user1 = User { email: String::from("someone@example.com"), username: String::from("someusername123"), active: true, sign_in_count: 1, }; user1.email = String::from("anotheremail@example.com"); } fn build_user(email: String, username: String) -> User { User { email: email, username: username, active: true, sign_in_count: 1, } } инициализации поля, чтобы переписать build_user так, чтобы он работал точно также,но не содержал повторений для email и username, как в листинге 5-5.Листинг 5-5: Функция build_user, использующая сокращённую инициализацию поля, когда параметры email и username имеют те же имена, что и поля structЗдесь происходит создание нового экземпляра структуры User, которая имеет поле с именем email. Мы хотим установить поле структуры email значением входного параметра email функции build_user. Так как поле email и входной параметр функции email имеют одинаковое название, можно писать просто email вместо кода email: emailСоздание экземпляра структуры из экземпляра другой структуры спомощью синтаксиса обновления структурыЧасто бывает полезно создать новый экземпляр структуры, который включает большинство значений из другого экземпляра, но некоторые из них изменяет. Это можно сделать с помощью синтаксиса обновления структуры.Сначала в листинге 5-6 показано, как обычно создаётся новый экземпляр User в user2без синтаксиса обновления. Мы задаём новое значение для email, но в остальном используем те же значения из user1, которые были заданы в листинге 5-2.Листинг 5-6: Создание нового экземпляра User с использованием некоторых значений из экземпляра user1Используя синтаксис обновления структуры, можно получить тот же эффект, используя меньше кода как показано в листинге 5-7. Синтаксис указывает, что оставшиеся поля fn build_user(email: String, username: String) -> User { User { email, username, active: true, sign_in_count: 1, } } fn main() { // --snip-- let user2 = User { active: user1.active, username: user1.username, email: String::from("another@example.com"), sign_in_count: user1.sign_in_count, }; } устанавливаются неявно и должны иметь значения из указанного экземпляра.Листинг 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, поэтому будет применяться поведение, о котором мы говорили в разделе "Стековые данные:Копирование"Кортежные структуры: структуры без именованных полей длясоздания разных типовRust также поддерживает структуры, похожие на кортежи, которые называютсякортежные структуры. Кортежные структуры обладают дополнительным смыслом,который даёт имя структуры, но при этом не имеют имён, связанных с их полями. Скорее,они просто хранят типы полей. Кортежные структуры полезны, когда вы хотите дать имя всему кортежу и сделать кортеж отличным от других кортежей, и когда именование каждого поля, как в обычной структуре, было бы многословным или избыточным.Чтобы определить кортежную структуру, начните с ключевого слова struct и имени структуры, за которым следуют типы в кортеже. Например, здесь мы определяем и используем две кортежные структуры с именами Color и Point:fn main() { // --snip-- let user2 = User { email: String::from("another@example.com"), ..user1 }; } Обратите внимание, что значения black и origin — это разные типы, потому что они являются экземплярами разных кортежных структур. Каждая определяемая вами структура имеет собственный тип, даже если поля внутри структуры могут иметь одинаковые типы. Например, функция, принимающая параметр типа Color, не может принимать Point в качестве аргумента, даже если оба типа состоят из трёх значений i32. В остальном экземпляры кортежных структур похожи на кортежи в том смысле, что вы можете деструктурировать их на отдельные части и использовать , за которой следует индекс для доступа к отдельному значению.Единично-подобные структуры: структуры без полейТакже можно определять структуры, не имеющие полей! Они называются единично-подобными структурами, поскольку ведут себя аналогично (), единичному типу, о котором мы говорили в разделе "Кортежи". Единично-подобные структуры могут быть полезны, когда требуется реализовать типаж для некоторого типа, но у вас нет данных,которые нужно хранить в самом типе. Мы обсудим типажи в главе 10. Вот пример объявления и создание экземпляра единичной структуры с именем AlwaysEqual:Чтобы определить AlwaysEqual, мы используем ключевое слово struct, желаемое имя,а затем точку с запятой. Нет необходимости в фигурных или круглых скобках! Затем мы можем получить экземпляр AlwaysEqual в переменной subject аналогичным образом:используя имя, которое мы определили, без фигурных и круглых скобок. Представим, что в дальнейшем мы реализуем поведение для этого типа таким образом, что каждый экземпляр AlwaysEqual всегда будет равен каждому экземпляру любого другого типа,возможно, с целью получения ожидаемого результата для тестирования. Для реализации такого поведения нам не нужны никакие данные! В главе 10 вы увидите, как определять черты и реализовывать их для любого типа, включая единично-подобные структуры.Владение данными структурыstructColor(i32, i32, i32); structPoint(i32, i32, i32); fn main() { let black = Color(0, 0, 0); let origin = Point(0, 0, 0); } structAlwaysEqual; fn main() { let subject = AlwaysEqual; } В определении структуры User в листинге 5-1 мы использовали владеющий тип String вместо типа строковой срез &str. Это осознанный выбор, поскольку мы хотим, чтобы каждый экземпляр этой структуры владел всеми своими данными и чтобы эти данные были действительны до тех пор, пока действительна вся структура.Структуры также могут хранить ссылки на данные, принадлежащие кому-то другому,но для этого необходимо использовать возможность Rust время жизни, которую мы обсудим в главе 10. Время жизни гарантирует, что данные, на которые ссылается структура, будут действительны до тех пор, пока существует структура. Допустим,если попытаться сохранить ссылку в структуре без указания времени жизни, как в следующем примере; это не сработает:Имя файла: src/main.rsКомпилятор будет жаловаться на необходимость определения времени жизни ссылок:structUser { active: bool, username: &str, email: &str, sign_in_count: u64, } fn main() { let user1 = User { email: "someone@example.com", username: "someusername123", active: true, sign_in_count: 1, }; } В главе 10 мы обсудим, как исправить эти ошибки, чтобы иметь возможность хранить ссылки в структурах, а пока мы исправим подобные ошибки, используя владеющие типы вроде String вместо ссылок &str$ 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` due to 2 previous errors Пример использования структурЧтобы понять, когда нам может понадобиться использование структур, давайте напишем программу, которая вычисляет площадь прямоугольника. Мы начнём с использования одиночных переменных, а затем будем улучшать программу до использования структур.Давайте создадим новый проект программы при помощи Cargo и назовём его rectangles.Наша программа будет получать на вход длину и ширину прямоугольника в пикселях и затем рассчитывать площадь прямоугольника. Листинг 5-8 показывает один из коротких вариантов кода, который позволит нам сделать именно то, что надо, в файле проектаsrc/main.rs.Файл: src/main.rsЛистинг 5-8: вычисление площади прямоугольника, заданного отдельными переменными ширины ивысотыТеперь запустим программу, используя cargo run:Этот код успешно вычисляет площадь прямоугольника, вызывая функцию area скаждым измерением, но мы можем улучшить его ясность и читабельность.Проблема данного метода очевидна из сигнатуры area:Функция area должна вычислять площадь одного прямоугольника, но функция, которую мы написали, имеет два параметра, и нигде в нашей программе не ясно, что эти параметры взаимосвязаны. Было бы более читабельным и управляемым сгруппировать fn main() { let width1 = 30; let height1 = 50; println!( "The area of the rectangle is {} square pixels.", area(width1, height1) ); } fn area(width: u32, height: u32) -> u32 { width * height } $ cargo run Compiling rectangles v0.1.0 (file:///projects/rectangles) Finished dev [unoptimized + debuginfo] target(s) in 0.42s Running `target/debug/rectangles` The area of the rectangle is 1500 square pixels. fn area(width: u32, height: u32) -> u32 { ширину и высоту вместе. В разделе «Кортежи» главы 3 мы уже обсуждали один из способов сделать это — использовать кортежи.Рефакторинг при помощи кортежейЛистинг 5-9 — это другая версия программы, использующая кортежи.Файл: src/main.rsЛистинг 5-9: определение ширины и высоты прямоугольника с помощью кортежаС одной стороны, эта программа лучше. Кортежи позволяют добавить немного структуры, и теперь мы передаём только один аргумент. Но с другой стороны, эта версия менее понятна: кортежи не называют свои элементы, поэтому нам приходится индексировать части кортежа, что делает наше вычисление менее очевидным.Если мы перепутаем местами ширину с высотой при расчёте площади, то это не имеет значения. Но если мы хотим нарисовать прямоугольник на экране, то это уже будет важно! Мы должны помнить, что ширина width находится в кортеже с индексом 0, а высота height — с индексом 1. Если кто-то другой поработал бы с кодом, ему бы пришлось разобраться в этом и также помнить про порядок. Легко забыть и перепутать эти значения — и это вызовет ошибки, потому что данный код не передаёт наши намерения.Рефакторинг при помощи структур: добавим больше смыслаМы используем структуры, чтобы добавить смысл данным при помощи назначения им осмысленных имён . Мы можем переделать используемый кортеж в структуру с единым именем для сущности и частными названиями её частей, как показано в листинге 5-10.Файл: src/main.rs fn main() { let rect1 = (30, 50); println!( "The area of the rectangle is {} square pixels.", area(rect1) ); } fn area(dimensions: (u32, u32)) -> u32 { dimensions.0 * dimensions.1} Листинг 5-10: определение структуры RectangleЗдесь мы определили структуру и дали ей имя Rectangle. Внутри фигурных скобок определили поля как width и height, оба — типа u32. Затем в main создали конкретный экземпляр Rectangle с шириной в 30 и высотой в 50 единиц.Наша функция area теперь определена с одним параметром, названным rectangle, чей тип является неизменяемым заимствованием структуры Rectangle. Как упоминалось в главе 4, необходимо заимствовать структуру, а не передавать её во владение. Таким образом функция main сохраняет rect1 в собственности и может использовать еёдальше. По этой причине мы и используем & в сигнатуре и в месте вызова функции.Функция area получает доступ к полям width и height экземпляра Rectangle (обратите внимание, что доступ к полям заимствованного экземпляра структуры не приводит к перемещению значений полей, поэтому вы часто видите заимствования структур). Наша сигнатура функции для area теперь говорит именно то, что мы имеем в виду: вычислить площадь Rectangle, используя его поля width и height. Это означает, что ширина и высота связаны друг с другом, и даёт описательные имена значениям, а не использует значения индекса кортежа 0 и 1. Это торжество ясности.Добавление полезной функциональности при помощи выводимых1 ... 6 7 8 9 10 11 12 13 ... 62

help: use `impl Fn(i32) -> i32` as the return type, as all return paths are of type `[closure@src/lib.rs:2:5: 2:14]`, which implements `Fn(i32) -> i32` | 1 | fn returns_closure() -> impl Fn(i32) -> i32 { |

Листинг 15-2: Первая попытка определить перечисление в качестве структуры данных cons list, состоящей
из
i32
значений.
Примечание: В данном примере мы реализуем cons list, который содержит только значения i32
. Мы могли бы реализовать его с помощью generics, о которых мы говорили в главе 10, чтобы определить тип cons list, который мог бы хранить значения любого типа.
Использование типа
List для хранения списка
1, 2, 3
будет выглядеть как код в листинге 15-3:
Файл: src/main.rs
Листинг 15-3: Использование перечисления
List
для хранения списка
1, 2, 3
enum
List
{
Cons(
i32
, List),
Nil,
} use crate::List::{Cons, Nil}; fn main
() { let list = Cons(
1
, Cons(
2
, Cons(
3
, Nil)));
}

Первое значение
Cons содержит
1
и другой
List
. Это значение
List является следующим значением
Cons
, которое содержит
2
и другой
List
. Это значение
List является ещё один значением
Cons
, которое содержит
3
и значение
List
, которое наконец является
Nil
, не рекурсивным вариантом, сигнализирующим об окончании списка.
Если мы попытаемся скомпилировать код в листинге 15-3, мы получим ошибку,
показанную в листинге 15-4:
Листинг 15-4: Ошибка, которую мы получаем при попытке определить рекурсивное перечисление
Ошибка говорит о том, что этот тип "имеет бесконечный размер". Причина в том, что мы определили
List в форме, которая является рекурсивной: она непосредственно хранит другое значение своего собственного типа. В результате Rust не может определить,
сколько места ему нужно для хранения значения
List
. Давайте разберёмся, почему мы получаем эту ошибку. Сначала мы рассмотрим, как Rust решает, сколько места ему нужно для хранения значения нерекурсивного типа.
Вычисление размера нерекурсивного типа
$
cargo run
Compiling cons-list v0.1.0 (file:///projects/cons-list) error[E0072]: recursive type `List` has infinite size
-->
src/main.rs:1:1
|
1 | enum List {
| ^^^^^^^^^ recursive type has infinite size
2 | Cons(i32, List),
| ---- recursive without indirection
| help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to make `List` representable
|
2 | Cons(i32, Box),
| ++++ + error[E0391]: cycle detected when computing drop-check constraints for `List`
-->
src/main.rs:1:1
|
1 | enum List {
| ^^^^^^^^^
|
= note: ...which immediately requires computing drop-check constraints for
`List` again
= note: cycle used when computing dropck types for `Canonical { max_universe:
U0, variables: [], value: ParamEnvAnd { param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst }, value: List } }`
Some errors have detailed explanations: E0072, E0391.
For more information about an error, try `rustc --explain E0072`. error: could not compile `cons-list` due to 2 previous errors

Вспомните перечисление
Message определённое в листинге 6-2, когда обсуждали объявление enum в главе 6:
Чтобы определить, сколько памяти выделять под значение
Message
, Rust проходит каждый из вариантов, чтобы увидеть, какой вариант требует наибольшее количество памяти. Rust видит, что для
Message::Quit не требуется места,
Message::Move хватает места для хранения двух значений i32
и т.д. Так как будет использоваться только один вариант, то наибольшее пространство, которое потребуется для значения
Message
, это пространство, которое потребуется для хранения самого большого из вариантов перечисления.
Сравните это с тем, что происходит, когда Rust пытается определить, сколько места необходимо рекурсивному типу, такому как перечисление
List в листинге 15-2.
Компилятор смотрит на вариант
Cons
, который содержит значение типа i32
и значение типа
List
. Следовательно,
Cons нужно пространство, равное размеру i32
плюс размер
List
. Чтобы выяснить, сколько памяти необходимо типу
List
, компилятор смотрит на варианты, начиная с
Cons
. Вариант
Cons содержит значение типа i32
и значение типа
List
, и этот процесс продолжается бесконечно, как показано на рисунке 15-1.
Cons i32
Cons i32
Cons i32
Cons i32
Cons i32 ∞
Рисунок 15-1: Бесконечный
List
, состоящий из нескончаемого числа вариантов
Cons
Использование Box для получения рекурсивного типа с известным размером
Поскольку Rust не может определить, сколько места нужно выделить для типов с рекурсивным определением, компилятор выдаёт ошибку с этим полезным предложением:
enum
Message
{
Quit,
Move { x: i32
, y: i32
},
Write(
String
),
ChangeColor(
i32
, i32
, i32
),
}

В данном предложении "перенаправление" означает, что вместо того, чтобы непосредственно хранить само значение, мы должны изменить структуру данных, так чтобы хранить его косвенно - хранить указатель на это значение.
Поскольку
Box
является указателем, Rust всегда знает, сколько места нужно
Box
:
размер указателя не меняется в зависимости от объёма данных, на которые он указывает. Это означает, что мы можем поместить
Box
внутрь экземпляра
Cons вместо значения
List напрямую.
Box
будет указывать на значение очередного
List
, который будет находиться в куче, а не внутри экземпляра
Cons
. Концептуально у нас все ещё есть список, созданный из списков, содержащих другие списки, но эта реализация теперь больше похожа на размещение элементов рядом друг с другом, а не внутри друг друга.
Мы можем изменить определение перечисления
List в листинге 15-2 и использование
List в листинге 15-3 на код из листинга 15-5, который будет компилироваться:
Файл: src/main.rs
Листинг 15-5: Определение
List
, которое использует
Box
для того, чтобы иметь вычисляемый размер
Cons требуется объём i32
плюс место для хранения данных указателя box.
Nil не хранит никаких значений, поэтому ему нужно меньше места, чем
Cons
. Теперь мы знаем, что любое значение
List займёт размер i32
плюс размер данных указателя box.
Используя box, мы разорвали бесконечную рекурсивную цепочку, поэтому компилятор может определить размер, необходимый для хранения значения
List
. На рисунке 15-2
показано, как теперь выглядит
Cons help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to make `List` representable
|
2 | Cons(i32, Box),
| ^^^^ ^ enum
List
{
Cons(
i32
,
Box
),
Nil,
} use crate::List::{Cons, Nil}; fn main
() { let list = Cons(
1
,
Box
::new(Cons(
2
,
Box
::new(Cons(
3
,
Box
::new(Nil))))));
}

Cons i32
Box usize
Рисунок 15-2:
List
, который не является бесконечно большим, потому что
Cons
хранит
Box
.
Box-ы обеспечивают только перенаправление и выделение в куче; у них нет никаких других специальных возможностей, подобных тем, которые мы увидим у других типов умных указателей. У них также нет накладных расходов на производительность, которые несут эти специальные возможности, поэтому они могут быть полезны в таких случаях,
как cons list, где перенаправление - единственная функция, которая нам нужна. В главе
17 мы также рассмотрим другие случаи использования box.
Тип
Box
является умным указателем, поскольку он реализует трейт
Deref
, который позволяет обрабатывать значения
Box
как ссылки. Когда значение
Box
выходит из области видимости, данные кучи, на которые указывает box, также очищаются благодаря реализации типажа
Drop
. Эти два трейта будут ещё более значимыми для функциональности, предоставляемой другими типами умных указателей, которые мы обсудим в оставшейся части этой главы. Давайте рассмотрим эти два типажа более подробно.

Обращение с умными указателями как с обычными
ссылками с помощью Deref типажа
Используя трейт
Deref
, вы можете изменить поведение оператора разыменования
*
(не путать с операторами умножения или глобального подключения). Реализовав
Deref таким образом, что умный указатель может рассматриваться как обычная ссылка, вы можете писать код, оперирующий ссылками, а также использовать этот код с умными указателями.
Давайте сначала посмотрим, как работает оператор разыменования с обычными ссылками. Затем мы попытаемся определить пользовательский тип, который ведёт себя как
Box
и посмотрим, почему оператор разыменования не работает как ссылка для нового объявленного типа. Мы рассмотрим, как реализация типажа
Deref делает возможным работу умных указателей аналогично ссылкам. Затем посмотрим на
разыменованное приведение (deref coercion) в Rust и как оно позволяет работать с любыми ссылками или умными указателями.
Примечание: есть одна большая разница между типом
MyBox
, который мы собираемся создать и реальным
Box
: наша версия не будет хранить свои данные в куче. В примере мы сосредоточимся на типаже
Deref
, поэтому менее важно то, где данные хранятся, чем поведение подобное указателю.
Следуя за указателем на значение
Обычная ссылка - это разновидность указателя, а указатель можно рассматривать как своеобразную стрелочку направляющую к значению, хранящемуся в другом месте. В
листинге 15-6 мы создаём ссылку на значение i32
, а затем используем оператор разыменования для перехода от ссылки к значению:
Файл: src/main.rs
Листинг 15-6: Использование оператора разыменования для следования по ссылке к значению
i32
Переменной x
присвоено значение
5
типа i32
. Мы установили в качестве значения y
ссылку на x
. Мы можем утверждать, что значение x
равно
5
. Однако, если мы хотим сделать утверждение о значении в y
, мы должны использовать
*y
, чтобы перейти по fn main
() { let x =
5
; let y = &x; assert_eq!
(
5
, x); assert_eq!
(
5
, *y);
}

ссылке к значению, на которое она указывает (таким образом, происходит
разыменование), для того чтобы компилятор при сравнении мог использовать фактическое значение. Как только мы разыменуем y
, мы получим доступ к целочисленному значению, на которое указывает y
, которое и будем сравнивать с
5
Если бы мы попытались написать assert_eq!(5, y);
, то получили ошибку компиляции:
Сравнение числа и ссылки на число не допускается, потому что они различных типов.
Мы должны использовать оператор разыменования, чтобы перейти по ссылке на значение, на которое она указывает.
Использование Box как ссылку
Мы можем переписать код в листинге 15-6, чтобы использовать
Box
вместо ссылки;
оператор разыменования, используемый для
Box
в листинге 15-7, работает так же,
как оператор разыменования, используемый для ссылки в листинге 15-6:
Файл: src/main.rs
$
cargo run
Compiling deref-example v0.1.0 (file:///projects/deref-example) error[E0277]: can't compare `{integer}` with `&{integer}`
-->
src/main.rs:6:5
|
6 | assert_eq!(5, y);
| ^^^^^^^^^^^^^^^^ no implementation for `{integer} == &{integer}`
|
= help: the trait `PartialEq<&{integer}>` is not implemented for `{integer}`
= help: the following other types implement trait `PartialEq`: f32 f64 i128 i16 i32 i64 i8 isize and 6 others
= note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
For more information about this error, try `rustc --explain E0277`. error: could not compile `deref-example` due to previous error fn main
() { let x =
5
; let y =
Box
::new(x); assert_eq!
(
5
, x); assert_eq!
(
5
, *y);
}

Листинг 15-7: Использование оператора разыменования с типом
Box
Разница между листингом 15-7 и листингом 15-6 состоит в том, что здесь мы устанавливаем y
на экземпляр box, указывающий на значение x
, а не ссылкой,
указывающей на значение x
. В последнем утверждении мы можем использовать оператор разыменования, чтобы проследовать за указателем box-а так же, как мы это делали когда y
была ссылкой. Далее мы рассмотрим, что особенного у типа
Box
, что позволяет нам использовать оператор разыменования, определяя наш собственный тип
Box
Определение собственного умного указателя
Давайте создадим умный указатель, похожий на тип
Box
предоставляемый стандартной библиотекой, чтобы понять как поведение умных указателей отличается от поведения обычной ссылки. Затем мы рассмотрим вопрос, как добавить возможность использовать оператор разыменования.
Тип
Box
в конечном итоге определяется как структура кортежа с одним элементом,
поэтому в листинге 15-8 аналогичным образом определяется
MyBox
. Мы также определим функцию new
, чтобы она соответствовала функции new
, определённой в
Box
Файл: src/main.rs
Листинг 15-8: Определение типа
MyBox
Мы определяем структуру с именем
MyBox и объявляем обобщённый параметр
T
,
потому что мы хотим, чтобы наш тип хранил значения любого типа. Тип
MyBox является структурой кортежа с одним элементом типа
T
. Функция
MyBox::new принимает один параметр типа
T
и возвращает экземпляр
MyBox
, который содержит переданное значение.
Давайте попробуем добавить функцию main из листинга 15-7 в листинг 15-8 и изменим её на использование типа
MyBox
, который мы определили вместо
Box
. Код в листинге 15-9 не будет компилироваться, потому что Rust не знает, как разыменовывать
MyBox
Файл: src/main.rs struct
MyBox
(T); impl
MyBox { fn new
(x: T) -> MyBox {
MyBox(x)
}
}

Листинг 15-9. Попытка использовать
MyBox
таким же образом, как мы использовали ссылки и
Box
Вот результат ошибки компиляции:
Наш тип
MyBox
не может быть разыменован, потому что мы не реализовали эту возможность. Чтобы включить разыменование с помощью оператора
*
, мы реализуем типаж
Deref
Трактование типа как ссылки реализуя типаж Deref
Как обсуждалось в разделе
“Реализация трейта для типа”
Главы 10, для реализации типажа нужно предоставить реализации требуемых методов типажа. Типаж
Deref
,
предоставляемый стандартной библиотекой требует от нас реализации одного метода с именем deref
, который заимствует self и возвращает ссылку на внутренние данные.
Листинг 15-10 содержит реализацию
Deref добавленную к определению
MyBox
:
Файл: src/main.rs
Листинг 15-10: Реализация
Deref
для типа
MyBox
fn main
() { let x =
5
; let y = MyBox::new(x); assert_eq!
(
5
, x); assert_eq!
(
5
, *y);
}
$
cargo run
Compiling deref-example v0.1.0 (file:///projects/deref-example) error[E0614]: type `MyBox<{integer}>` cannot be dereferenced
-->
src/main.rs:14:19
|
14 | assert_eq!(5, *y);
| ^^
For more information about this error, try `rustc --explain E0614`. error: could not compile `deref-example` due to previous error use std::ops::Deref; impl
Deref for
MyBox { type
Target
= T; fn deref
(&
self
) -> &Self::Target {
&
self
0
}
}

Синтаксис type Target = T;
определяет связанный тип для использования у типажа
Deref
. Связанные типы - это немного другой способ объявления обобщённого параметра, но пока вам не нужно о них беспокоиться; мы рассмотрим их более подробно в главе 19.
Мы заполним тело метода deref оператором
&self.0
, чтобы deref вернул ссылку на значение, к которому мы хотим получить доступ с помощью оператора
*
; вспомним из раздела "Using Tuple Structs without Named Fields to Create Diﬀerent Types"
главы 5, что
.0
получает доступ к первому значению в кортежной структуре. Функция main в листинге
15-9, которая вызывает
*
для значения
MyBox
, теперь компилируется, и проверки проходят!
Без типажа
Deref компилятор может только разыменовывать
&
ссылки. Метод deref даёт компилятору возможность принимать значение любого типа, реализующего
Deref и вызывать метод deref чтобы получить ссылку
&
, которую он знает, как разыменовывать.
Когда мы ввели
*y в листинге 15-9, Rust фактически выполнил за кулисами такой код:
Rust заменяет оператор
*
вызовом метода deref и затем простое разыменование,
поэтому нам не нужно думать о том, нужно ли нам вызывать метод deref
. Эта функция
Rust позволяет писать код, который функционирует одинаково, независимо от того, есть ли у нас обычная ссылка или тип, реализующий типаж
Deref
Причина, по которой метод deref возвращает ссылку на значение, и что простое разыменование вне круглых скобок в
*(y.deref())
все ещё необходимо, связана с системой владения. Если бы метод deref возвращал значение напрямую, а не ссылку на него, значение переместилось бы из self
. Мы не хотим передавать владение внутренним значением внутри
MyBox
в этом случае и в большинстве случаев, когда мы используем оператор разыменования.
Обратите внимание, что оператор
*
заменён вызовом метода deref
, а затем вызовом оператора
*
только один раз, каждый раз, когда мы используем
*
в коде. Поскольку замена оператора
*
не повторяется бесконечно, мы получаем данные типа i32
,
которые соответствуют
5
в assert_eq!
листинга 15-9.
Неявные разыменованные приведения с функциями и методами
Разыменованное приведение преобразует ссылку на тип, который реализует признак
Deref
, в ссылку на другой тип. Например, deref coercion может преобразовать
&String в
&str
, потому что
String реализует признак
Deref
, который возвращает
&str
. Deref coercion - это удобный механизм, который Rust использует для аргументов функций и
*(y.deref())

Смотрите также файлы

Выполнение практических заданий по дисциплине административное право.docx

Лабораторная работа 1 Кобеидзе Николай Пример П1.docx

Рабочая программа по английскому языку.docx

Выбрать слово, в котором согласная буква s читается не так, как в остальных предложенных словах.docx

Задача 3 Общин положения.docx

Файл: Язык программирования Rust.pdf

Смотрите также файлы

Информация

Списки файлов

Дополнительно