Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Выполнение кода при очистке с помощью трейта Drop

Второй трейт, важный для паттерна умных указателей, — это Drop, который позволяет настроить, что происходит, когда значение вот-вот выйдет из области видимости. Вы можете предоставить реализацию трейта Drop для любого типа, и этот код может использоваться для освобождения ресурсов, таких как файлы или сетевые соединения.

Мы вводим Drop в контексте умных указателей, потому что функциональность трейта Drop почти всегда используется при реализации умного указателя. Например, когда Box<T> уничтожается, он освобождает пространство в куче, на которое указывает box.

В некоторых языках для некоторых типов программист должен вызывать код для освобождения памяти или ресурсов каждый раз, когда он заканчивает использовать экземпляр этих типов. Примеры включают файловые дескрипторы, сокеты и блокировки. Если программист забудет, система может перегрузиться и упасть. В Rust вы можете указать, что конкретный фрагмент кода должен выполняться всякий раз, когда значение выходит из области видимости, и компилятор вставит этот код автоматически. В результате вам не нужно быть осторожным с размещением кода очистки везде в программе, где экземпляр конкретного типа закончил использоваться — вы всё равно не допустите утечки ресурсов!

Вы указываете код, который должен выполняться, когда значение выходит из области видимости, реализуя трейт Drop. Трейт Drop требует реализовать один метод с именем drop, который принимает изменяемую ссылку на self. Чтобы увидеть, когда Rust вызывает drop, давайте пока реализуем drop с операторами println!.

Листинг 15-14 показывает структуру CustomSmartPointer, единственная настраиваемая функциональность которой — печать Dropping CustomSmartPointer!, когда экземпляр выходит из области видимости, чтобы показать, когда Rust запускает метод drop.

Имя файла: src/main.rs
struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}

fn main() {
    let c = CustomSmartPointer {
        data: String::from("my stuff"),
    };
    let d = CustomSmartPointer {
        data: String::from("other stuff"),
    };
    println!("CustomSmartPointers created");
}
Листинг 15-14: Структура CustomSmartPointer, которая реализует трейт Drop, где мы поместили бы наш код очистки

Трейт Drop включён в прелюдию, так что нам не нужно вводить его в область видимости. Мы реализуем трейт Drop для CustomSmartPointer и предоставляем реализацию метода drop, который вызывает println!. Тело метода drop — это место, куда вы поместили бы любую логику, которую хотели бы выполнить, когда экземпляр вашего типа выходит из области видимости. Здесь мы печатаем некоторый текст, чтобы визуально продемонстрировать, когда Rust вызовет drop.

В main мы создаём два экземпляра CustomSmartPointer, а затем печатаем CustomSmartPointers created. В конце main наши экземпляры CustomSmartPointer выйдут из области видимости, и Rust вызовет код, который мы поместили в метод drop, напечатав наше финальное сообщение. Обратите внимание, что нам не нужно было вызывать метод drop явно.

Когда мы запустим эту программу, мы увидим следующий вывод:

$ cargo run
   Compiling drop-example v0.1.0 (file:///projects/drop-example)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.60s
     Running `target/debug/drop-example`
CustomSmartPointers created
Dropping CustomSmartPointer with data `other stuff`!
Dropping CustomSmartPointer with data `my stuff`!

Rust автоматически вызвал drop за нас, когда наши экземпляры вышли из области видимости, выполнив код, который мы указали. Переменные уничтожаются в обратном порядке их создания, поэтому d был уничтожен раньше c. Цель этого примера — дать вам визуальное руководство о том, как работает метод drop; обычно вы бы указывали код очистки, который нужен вашему типу, а не печать сообщения.

К сожалению, отключить автоматическую функциональность drop не так просто. Отключение drop обычно не нужно; весь смысл трейта Drop в том, что он обрабатывается автоматически. Иногда, однако, вы можете захотеть очистить значение раньше. Один из примеров — при использовании умных указателей, управляющих блокировками: вы можете захотеть принудительно вызвать метод drop, который освобождает блокировку, чтобы другой код в той же области видимости мог получить блокировку. Rust не позволяет вам вызывать метод drop трейта Drop вручную; вместо этого вам нужно вызвать функцию std::mem::drop, предоставляемую стандартной библиотекой, если вы хотите принудительно уничтожить значение до конца его области видимости.

Попытка вызвать метод drop трейта Drop вручную, изменив функцию main из листинга 15-14, не сработает, как показано в листинге 15-15.

Имя файла: src/main.rs
struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}

fn main() {
    let c = CustomSmartPointer {
        data: String::from("some data"),
    };
    println!("CustomSmartPointer created");
    c.drop();
    println!("CustomSmartPointer dropped before the end of main");
}
Листинг 15-15: Попытка вызвать метод drop трейта Drop вручную для ранней очистки

Когда мы попытаемся скомпилировать этот код, мы получим эту ошибку:

$ cargo run
   Compiling drop-example v0.1.0 (file:///projects/drop-example)
error[E0040]: explicit use of destructor method
  --> src/main.rs:16:7
   |
16 |     c.drop();
   |       ^^^^ explicit destructor calls not allowed
   |
help: consider using `drop` function
   |
16 -     c.drop();
16 +     drop(c);
   |

For more information about this error, try `rustc --explain E0040`.
error: could not compile `drop-example` (bin "drop-example") due to 1 previous error

Это сообщение об ошибке говорит, что нам не разрешено явно вызывать drop. В сообщении об ошибке используется термин деструктор, который является общим программистским термином для функции, которая очищает экземпляр. Деструктор аналогичен конструктору, который создаёт экземпляр. Функция drop в Rust — это один из конкретных деструкторов.

Rust не позволяет нам вызывать drop явно, потому что Rust всё равно автоматически вызовет drop для значения в конце main. Это вызовет ошибку двойного освобождения, потому что Rust попытается очистить одно и то же значение дважды.

Мы не можем отключить автоматическую вставку drop, когда значение выходит из области видимости, и мы не можем вызвать метод drop явно. Поэтому, если нам нужно принудительно очистить значение раньше, мы используем функцию std::mem::drop.

Функция std::mem::drop отличается от метода drop в трейте Drop. Мы вызываем её, передавая в качестве аргумента значение, которое хотим принудительно уничтожить. Функция находится в прелюдии, поэтому мы можем изменить main в листинге 15-15, чтобы вызвать функцию drop, как показано в листинге 15-16.

Имя файла: src/main.rs
struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}

fn main() {
    let c = CustomSmartPointer {
        data: String::from("some data"),
    };
    println!("CustomSmartPointer created");
    drop(c);
    println!("CustomSmartPointer dropped before the end of main");
}
Листинг 15-16: Вызов std::mem::drop для явного уничтожения значения до того, как оно выйдет из области видимости

Запуск этого кода напечатает следующее:

$ cargo run
   Compiling drop-example v0.1.0 (file:///projects/drop-example)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.73s
     Running `target/debug/drop-example`
CustomSmartPointer created
Dropping CustomSmartPointer with data `some data`!
CustomSmartPointer dropped before the end of main

Текст Dropping CustomSmartPointer with data `some data`! печатается между текстом CustomSmartPointer created и CustomSmartPointer dropped before the end of main, показывая, что код метода drop вызывается для уничтожения c в этот момент.

Вы можете использовать код, указанный в реализации трейта Drop, многими способами, чтобы сделать очистку удобной и безопасной: например, вы можете использовать его для создания вашего собственного аллокатора памяти! С трейтом Drop и системой владения Rust вам не нужно помнить об очистке, потому что Rust делает это автоматически.

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

Теперь, когда мы рассмотрели Box<T> и некоторые характеристики умных указателей, давайте посмотрим на несколько других умных указателей, определённых в стандартной библиотеке.