Обращение с умными указателями как с обычными ссылками
Реализация трейта Deref позволяет настроить поведение
оператора разыменования * (не путать с оператором умножения или
glob-оператором). Реализуя Deref так, что с умным указателем можно
обращаться как с обычной ссылкой, можно писать код, работающий с
ссылками, и использовать этот код также с умными указателями.
Сначала рассмотрим, как оператор разыменования работает с обычными ссылками.
Затем попробуем определить пользовательский тип, который ведёт себя как Box<T>, и посмотрим, почему
оператор разыменования не работает как со ссылкой на нашем только что определённом
типе. Мы исследуем, как реализация трейта Deref позволяет
умным указателям работать подобно ссылкам. Затем рассмотрим
возможность Rust под названием «разыменовывающее приведение» (deref coercion) и то, как она позволяет работать
как со ссылками, так и с умными указателями.
Переход по ссылке к значению
Обычная ссылка — это разновидность указателя, и один из способов думать об указателе —
это стрелка к значению, хранящемуся где-то ещё. В листинге 15-6 мы создаём
ссылку на значение i32 и затем используем оператор разыменования, чтобы перейти по
ссылке к значению.
fn main() {
let x = 5;
let y = &x;
assert_eq!(5, x);
assert_eq!(5, *y);
}
i32Переменная x хранит значение i32, равное 5. Мы устанавливаем y равной ссылке на
x. Мы можем утверждать, что x равно 5. Однако если мы хотим сделать
утверждение о значении в y, нам нужно использовать *y, чтобы перейти по ссылке
к значению, на которое она указывает (отсюда разыменование), чтобы компилятор мог
сравнить фактическое значение. Как только мы разыменуем y, мы получаем доступ к
целочисленному значению, на которое указывает y, и можем сравнить его с 5.
Если бы мы попытались написать assert_eq!(5, y); вместо этого, мы получили бы такую ошибку
компиляции:
$ 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<Rhs>`:
f128
f16
f32
f64
i128
i16
i32
i64
and 8 others
For more information about this error, try `rustc --explain E0277`.
error: could not compile `deref-example` (bin "deref-example") due to 1 previous error
Сравнивать число и ссылку на число не разрешается, потому что это разные типы. Мы должны использовать оператор разыменования, чтобы перейти по ссылке к значению, на которое она указывает.
Использование Box<T> как ссылки
Мы можем переписать код из листинга 15-6, чтобы использовать Box<T> вместо
ссылки; оператор разыменования, применённый к Box<T> в листинге 15-7,
работает так же, как оператор разыменования, применённый к ссылке в
листинге 15-6.
fn main() {
let x = 5;
let y = Box::new(x);
assert_eq!(5, x);
assert_eq!(5, *y);
}
Box<i32>Основное отличие листинга 15-7 от листинга 15-6 в том, что здесь мы устанавливаем
y как экземпляр бокса, указывающего на скопированное значение x, а не
ссылку, указывающую на значение x. В последнем утверждении мы можем использовать
оператор разыменования, чтобы перейти по указателю бокса так же, как мы делали,
когда y была ссылкой. Далее мы исследуем, что особенного в Box<T>,
что позволяет нам использовать оператор разыменования, определив собственный тип бокса.
Определение собственного умного указателя
Давайте создадим тип-обёртку, аналогичный типу Box<T>, предоставляемому
стандартной библиотекой, чтобы на практике увидеть, как типы умных указателей по умолчанию ведут себя иначе, чем
ссылки. Затем рассмотрим, как добавить возможность использовать
оператор разыменования.
Примечание: есть одно большое различие между типом MyBox<T>, который мы собираемся
создать, и настоящим Box<T>: наша версия не будет хранить свои данные в куче.
Мы сосредоточены в этом примере на Deref, поэтому то, где на самом деле хранятся данные,
менее важно, чем поведение, подобное указателю.
Тип Box<T> в конечном итоге определён как кортежная структура с одним элементом, поэтому
листинг 15-8 определяет тип MyBox<T> таким же образом. Мы также определим
функцию new, чтобы соответствовать функции new, определённой на Box<T>.
struct MyBox<T>(T);
impl<T> MyBox<T> {
fn new(x: T) -> MyBox<T> {
MyBox(x)
}
}
fn main() {}
MyBox<T>Мы определяем структуру с именем MyBox и объявляем обобщённый параметр T, потому что
хотим, чтобы наш тип хранил значения любого типа. Тип MyBox — это кортежная структура
с одним элементом типа T. Функция MyBox::new принимает один параметр
типа T и возвращает экземпляр MyBox, хранящий переданное значение.
Давайте попробуем добавить функцию main из листинга 15-7 в листинг 15-8 и
изменить её, чтобы использовать определённый нами тип MyBox<T> вместо Box<T>. Код
в листинге 15-9 не скомпилируется, потому что Rust не знает, как
разыменовать MyBox.
struct MyBox<T>(T);
impl<T> MyBox<T> {
fn new(x: T) -> MyBox<T> {
MyBox(x)
}
}
fn main() {
let x = 5;
let y = MyBox::new(x);
assert_eq!(5, x);
assert_eq!(5, *y);
}
MyBox<T> так же, как мы использовали ссылки и Box<T>Вот полученная ошибка компиляции:
$ 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);
| ^^ can't be dereferenced
For more information about this error, try `rustc --explain E0614`.
error: could not compile `deref-example` (bin "deref-example") due to 1 previous error
Наш тип MyBox<T> не может быть разыменован, потому что мы не реализовали эту
возможность для нашего типа. Чтобы включить разыменование с помощью оператора *, мы
реализуем трейт Deref.
Реализация трейта Deref
Как обсуждалось в разделе «Реализация трейта для типа» в
главе 10, чтобы реализовать трейт, нам нужно предоставить реализации для
обязательных методов трейта. Трейт Deref, предоставляемый стандартной библиотекой,
требует от нас реализации одного метода с именем deref, который заимствует self и
возвращает ссылку на внутренние данные. Листинг 15-10 содержит реализацию
Deref, которую нужно добавить к определению MyBox<T>.
use std::ops::Deref;
impl<T> Deref for MyBox<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.0
}
}
struct MyBox<T>(T);
impl<T> MyBox<T> {
fn new(x: T) -> MyBox<T> {
MyBox(x)
}
}
fn main() {
let x = 5;
let y = MyBox::new(x);
assert_eq!(5, x);
assert_eq!(5, *y);
}
Deref для MyBox<T>Синтаксис type Target = T; определяет ассоциированный тип, который будет использовать трейт Deref.
Ассоциированные типы — это немного иной способ объявления обобщённого
параметра, но пока о них не нужно беспокоиться; мы рассмотрим их
подробнее в главе 20.
Мы заполняем тело метода deref выражением &self.0, чтобы deref
возвращал ссылку на значение, к которому мы хотим получить доступ с помощью оператора *;
напомним из раздела «Создание разных типов с помощью кортежных структур» в главе 5, что .0 обращается к первому значению в кортежной структуре.
Функция main в листинге 15-9, которая вызывает * для значения MyBox<T>, теперь
компилируется, и утверждения проходят!
Без трейта Deref компилятор может разыменовывать только ссылки &.
Метод deref даёт компилятору возможность взять значение любого типа,
реализующего Deref, и вызвать метод deref, чтобы получить ссылку, которую
он умеет разыменовывать.
Когда мы ввели *y в листинге 15-9, за кулисами Rust фактически выполнил такой
код:
*(y.deref())
Rust заменяет оператор * вызовом метода deref, а затем
обычным разыменованием, чтобы нам не приходилось думать о том, нужно ли
вызывать метод deref. Эта возможность Rust позволяет нам писать код, который работает
одинаково независимо от того, есть ли у нас обычная ссылка или тип, реализующий
Deref.
Причина, по которой метод deref возвращает ссылку на значение, и то, что
обычное разыменование за скобками в *(y.deref()) всё ещё необходимо,
связаны с системой владения. Если бы метод deref возвращал значение
напрямую, а не ссылку на значение, значение было бы перемещено из
self. Мы не хотим брать владение внутренним значением внутри MyBox<T> в
этом случае или в большинстве случаев, когда мы используем оператор разыменования.
Обратите внимание, что оператор * заменяется вызовом метода deref, а
затем вызовом оператора * только один раз, каждый раз, когда мы используем * в нашем коде.
Поскольку замена оператора * не рекурсивна бесконечно, мы
в итоге получаем данные типа i32, которые соответствуют 5 в assert_eq! в
листинге 15-9.
Использование разыменовывающего приведения в функциях и методах
Разыменовывающее приведение (deref coercion) преобразует ссылку на тип, реализующий трейт Deref,
в ссылку на другой тип. Например, разыменовывающее приведение может преобразовать
&String в &str, потому что String реализует трейт Deref так, что он
возвращает &str. Разыменовывающее приведение — это удобство, которое Rust применяет к аргументам
функций и методов, и оно работает только с типами, реализующими трейт Deref.
Оно происходит автоматически, когда мы передаём ссылку на значение определённого типа
в качестве аргумента функции или методу, которые не соответствуют типу параметра
в определении функции или метода. Последовательность вызовов метода deref
преобразует предоставленный нами тип в тип, который нужен параметру.
Разыменовывающее приведение было добавлено в Rust, чтобы программистам, пишущим вызовы функций и
методов, не нужно было добавлять так много явных ссылок и разыменований
с помощью & и *. Возможность разыменовывающего приведения также позволяет нам писать больше кода, который
может работать как со ссылками, так и с умными указателями.
Чтобы увидеть разыменовывающее приведение в действии, давайте используем тип MyBox<T>, который мы определили в
листинге 15-8, а также реализацию Deref, которую мы добавили в листинге
15-10. Листинг 15-11 показывает определение функции с параметром
среза строки.
fn hello(name: &str) {
println!("Hello, {name}!");
}
fn main() {}
hello с параметром name типа &strМы можем вызвать функцию hello со срезом строки в качестве аргумента, например
hello("Rust");. Разыменовывающее приведение позволяет вызвать hello
со ссылкой на значение типа MyBox<String>, как показано в листинге 15-12.
use std::ops::Deref;
impl<T> Deref for MyBox<T> {
type Target = T;
fn deref(&self) -> &T {
&self.0
}
}
struct MyBox<T>(T);
impl<T> MyBox<T> {
fn new(x: T) -> MyBox<T> {
MyBox(x)
}
}
fn hello(name: &str) {
println!("Hello, {name}!");
}
fn main() {
let m = MyBox::new(String::from("Rust"));
hello(&m);
}
hello со ссылкой на значение MyBox<String>, что работает благодаря разыменовывающему приведениюЗдесь мы вызываем функцию hello с аргументом &m, который является
ссылкой на значение MyBox<String>. Поскольку мы реализовали трейт Deref
для MyBox<T> в листинге 15-10, Rust может преобразовать &MyBox<String> в &String
путём вызова deref. Стандартная библиотека предоставляет реализацию Deref
для String, которая возвращает срез строки, и это есть в документации API
для Deref. Rust снова вызывает deref, чтобы превратить &String в &str, что
соответствует определению функции hello.
Если бы Rust не реализовал разыменовывающее приведение, нам пришлось бы написать код
из листинга 15-13 вместо кода из листинга 15-12, чтобы вызвать hello со значением
типа &MyBox<String>.
use std::ops::Deref;
impl<T> Deref for MyBox<T> {
type Target = T;
fn deref(&self) -> &T {
&self.0
}
}
struct MyBox<T>(T);
impl<T> MyBox<T> {
fn new(x: T) -> MyBox<T> {
MyBox(x)
}
}
fn hello(name: &str) {
println!("Hello, {name}!");
}
fn main() {
let m = MyBox::new(String::from("Rust"));
hello(&(*m)[..]);
}
(*m) разыменовывает MyBox<String> в String. Затем & и
[..] берут срез строки из String, равный всей строке, чтобы
соответствовать сигнатуре hello. Этот код без разыменовывающего приведения труднее
читать, писать и понимать со всеми этими символами. Разыменовывающее приведение
позволяет Rust обрабатывать эти преобразования за нас автоматически.
Когда трейт Deref определён для задействованных типов, Rust проанализирует
типы и будет использовать Deref::deref столько раз, сколько необходимо, чтобы получить ссылку,
соответствующую типу параметра. Количество раз, которое нужно вставить Deref::deref,
определяется во время компиляции, поэтому за использование разыменовывающего приведения
нет никаких затрат во время выполнения!
Обработка разыменовывающего приведения с изменяемыми ссылками
Подобно тому, как вы используете трейт Deref для переопределения оператора * для
неизменяемых ссылок, вы можете использовать трейт DerefMut для переопределения оператора *
для изменяемых ссылок.
Rust выполняет разыменовывающее приведение, когда находит типы и реализации трейтов в трёх случаях:
- Из
&Tв&U, когдаT: Deref<Target=U> - Из
&mut Tв&mut U, когдаT: DerefMut<Target=U> - Из
&mut Tв&U, когдаT: Deref<Target=U>
Первые два случая одинаковы, за исключением того, что второй реализует изменяемость.
Первый случай утверждает, что если у вас есть &T и T реализует Deref к
некоторому типу U, вы можете прозрачно получить &U. Второй случай утверждает, что
то же разыменовывающее приведение происходит для изменяемых ссылок.
Третий случай сложнее: Rust также приведёт изменяемую ссылку к неизменяемой. Но обратное невозможно: неизменяемые ссылки никогда не будут приведены к изменяемым ссылкам. Из-за правил заимствования, если у вас есть изменяемая ссылка, эта изменяемая ссылка должна быть единственной ссылкой на эти данные (иначе программа не скомпилируется). Преобразование одной изменяемой ссылки в одну неизменяемую ссылку никогда не нарушит правила заимствования. Преобразование неизменяемой ссылки в изменяемую потребовало бы, чтобы исходная неизменяемая ссылка была единственной неизменяемой ссылкой на эти данные, но правила заимствования этого не гарантируют. Поэтому Rust не может сделать предположение, что преобразование неизменяемой ссылки в изменяемую возможно.