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

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

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

Нажмите ? для отображения этой справки

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

Обращение с умными указателями как с обычными ссылками

Реализация трейта Deref позволяет настроить поведение оператора разыменования * (не путать с оператором умножения или glob-оператором). Реализуя Deref так, что с умным указателем можно обращаться как с обычной ссылкой, можно писать код, работающий с ссылками, и использовать этот код также с умными указателями.

Сначала рассмотрим, как оператор разыменования работает с обычными ссылками. Затем попробуем определить пользовательский тип, который ведёт себя как Box<T>, и посмотрим, почему оператор разыменования не работает как со ссылкой на нашем только что определённом типе. Мы исследуем, как реализация трейта Deref позволяет умным указателям работать подобно ссылкам. Затем рассмотрим возможность Rust под названием «разыменовывающее приведение» (deref coercion) и то, как она позволяет работать как со ссылками, так и с умными указателями.

Переход по ссылке к значению

Обычная ссылка — это разновидность указателя, и один из способов думать об указателе — это стрелка к значению, хранящемуся где-то ещё. В листинге 15-6 мы создаём ссылку на значение i32 и затем используем оператор разыменования, чтобы перейти по ссылке к значению.

Имя файла: src/main.rs
fn main() {
    let x = 5;
    let y = &x;

    assert_eq!(5, x);
    assert_eq!(5, *y);
}
Листинг 15-6: Использование оператора разыменования для перехода по ссылке к значению 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.

Имя файла: src/main.rs
fn main() {
    let x = 5;
    let y = Box::new(x);

    assert_eq!(5, x);
    assert_eq!(5, *y);
}
Листинг 15-7: Использование оператора разыменования с 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>.

Имя файла: src/main.rs
struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

fn main() {}
Листинг 15-8: Определение типа MyBox<T>

Мы определяем структуру с именем MyBox и объявляем обобщённый параметр T, потому что хотим, чтобы наш тип хранил значения любого типа. Тип MyBox — это кортежная структура с одним элементом типа T. Функция MyBox::new принимает один параметр типа T и возвращает экземпляр MyBox, хранящий переданное значение.

Давайте попробуем добавить функцию main из листинга 15-7 в листинг 15-8 и изменить её, чтобы использовать определённый нами тип MyBox<T> вместо Box<T>. Код в листинге 15-9 не скомпилируется, потому что Rust не знает, как разыменовать MyBox.

Имя файла: src/main.rs
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);
}
Листинг 15-9: Попытка использовать 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>.

Имя файла: src/main.rs
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);
}
Листинг 15-10: Реализация 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 показывает определение функции с параметром среза строки.

Имя файла: src/main.rs
fn hello(name: &str) {
    println!("Hello, {name}!");
}

fn main() {}
Листинг 15-11: Функция hello с параметром name типа &str

Мы можем вызвать функцию hello со срезом строки в качестве аргумента, например hello("Rust");. Разыменовывающее приведение позволяет вызвать hello со ссылкой на значение типа MyBox<String>, как показано в листинге 15-12.

Имя файла: src/main.rs
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);
}
Листинг 15-12: Вызов 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>.

Имя файла: src/main.rs
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)[..]);
}
Листинг 15-13: Код, который нам пришлось бы написать, если бы в Rust не было разыменовывающего приведения

(*m) разыменовывает MyBox<String> в String. Затем & и [..] берут срез строки из String, равный всей строке, чтобы соответствовать сигнатуре hello. Этот код без разыменовывающего приведения труднее читать, писать и понимать со всеми этими символами. Разыменовывающее приведение позволяет Rust обрабатывать эти преобразования за нас автоматически.

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

Обработка разыменовывающего приведения с изменяемыми ссылками

Подобно тому, как вы используете трейт Deref для переопределения оператора * для неизменяемых ссылок, вы можете использовать трейт DerefMut для переопределения оператора * для изменяемых ссылок.

Rust выполняет разыменовывающее приведение, когда находит типы и реализации трейтов в трёх случаях:

  1. Из &T в &U, когда T: Deref<Target=U>
  2. Из &mut T в &mut U, когда T: DerefMut<Target=U>
  3. Из &mut T в &U, когда T: Deref<Target=U>

Первые два случая одинаковы, за исключением того, что второй реализует изменяемость. Первый случай утверждает, что если у вас есть &T и T реализует Deref к некоторому типу U, вы можете прозрачно получить &U. Второй случай утверждает, что то же разыменовывающее приведение происходит для изменяемых ссылок.

Третий случай сложнее: Rust также приведёт изменяемую ссылку к неизменяемой. Но обратное невозможно: неизменяемые ссылки никогда не будут приведены к изменяемым ссылкам. Из-за правил заимствования, если у вас есть изменяемая ссылка, эта изменяемая ссылка должна быть единственной ссылкой на эти данные (иначе программа не скомпилируется). Преобразование одной изменяемой ссылки в одну неизменяемую ссылку никогда не нарушит правила заимствования. Преобразование неизменяемой ссылки в изменяемую потребовало бы, чтобы исходная неизменяемая ссылка была единственной неизменяемой ссылкой на эти данные, но правила заимствования этого не гарантируют. Поэтому Rust не может сделать предположение, что преобразование неизменяемой ссылки в изменяемую возможно.