Управление памятью в Rust: идиома RAII, указатель Box и механизмы Deref Coercion

Введение

#

При работе с системными ресурсами - выделенной памятью в куче, открытыми файлами или сетевыми сокетами - одна из главных трудностей в программировании заключается в их своевременном и гарантированном освобождении. Забытый вызов free() ведет к постоянным утечкам памяти, а преждевременное удаление - к уязвимостям вроде use-after-free или double free.

В Rust за порядок с ресурсами отвечает идиома управления ресурсами RAII (Resource Acquisition Is Initialization).

В языках с ручным управлением разработчик вынужден лично отслеживать точки выхода из функций, а в языках со сборщиком мусора (Java, Go, Python) специальный рантайм фоном ищет неиспользуемые объекты. В Rust же компилятор автоматически связывает время жизни ресурса со временем жизни его владельца.

Сегодня мы разберем, как работает идиома RAII, для чего нужен владеющий указатель Box<T>, когда полезно отменить автоматическое освобождение через Box::leak и как устроено автоматическое приведение ссылок Deref Coercion.

1. Идиома RAII и трейт Drop

#

В Rust владение ресурсом (память в куче, открытый файл, сетевой сокет, мютекс) обычно привязано к времени жизни значения.

• Ресурс захватывается при создании переменной (в ее конструкторе или функции new).
• Ресурс освобождается в тот момент, когда переменная выходит за пределы своей области видимости (scope).

Как устроен трейт Drop?

#

За очистку ресурсов отвечает трейт std::ops::Drop. Когда значение выходит из области видимости, Rust автоматически запускает его Drop::drop, если тип реализует Drop. После этого автоматически уничтожаются его поля.

struct CustomResource {
    name: String,
}

impl Drop for CustomResource {
    fn drop(&mut self) {
        println!("Освобождаем ресурс: {}", self.name);
    }
}

fn main() {
    {
        let res = CustomResource { name: "Файл конфигурации".into() };
        println!("Работаем с ресурсом...");
    } // <- Переменная res выходит из блока: автоматически вызывается drop()!
    
    println!("Программа идет дальше.");
}

Всегда ли освобождение ресурса гарантировано?

#

Трейт Drop не является абсолютной гарантией освобождения ресурса при любых обстоятельствах. Деструкторы не вызовутся, если:

• std::mem::forget(res) намеренно предотвращает уничтожение значения и, соответственно, вызов Drop.
• Циклическая структура из Rc или Arc может сохранить значения живыми навсегда: счетчик ссылок не достигает нуля, поэтому Drop для объектов в цикле не вызывается.
• Происходит экстренное аварийное завершение процесса (SIGKILL, std::process::abort).

2. Владеющий указатель Box

#

Локальные значения в Rust обычно размещаются на стеке. Если нужно явно разместить значение в куче, используется Box<T>.

Зачем нужен Box?

#

Сам Box<T> представляет собой владеющий указатель на объект в куче. Для обычного Sized-типа размер Box<T> на стеке обычно соответствует размеру указателя - 8 байт на 64-битной платформе.

Box<T> используется в нескольких ключевых сценариях:

1. Рекурсивные типы данных: Без Box компилятор не сможет определить конечный размер типа в памяти:

   enum List {
       Cons(i32, Box<List>),
       Nil,
   }

   Здесь Box необходим не ради оптимизации: без него List содержал бы сам себя напрямую, вызывая бесконечную рекурсию при расчете размера.
2. Размещение крупных структур в куче: Когда большой объект удобнее хранить отдельно от локальных данных на стеке.
3. Хранение трейт-объектов (Box<dyn Trait>): Позволяет работать с динамическим полиморфизмом.
4. Стабильный адрес объекта: Сам Box<T> можно перемещать по стеку, при этом сам объект T в куче остается на том же месте в памяти.

struct BigData {
    values: [u8; 10000],
}

fn main() {
    // Данные размещаются в куче
    let mut boxed_data = Box::new(BigData { values: [0; 10000] });
    
    // Модифицируем данные по указателю
    boxed_data.values[0] = 42;
} // При выходе boxed_data из scope освобождается память в куче!

Отмена деаллокации: Box::leak

#

Иногда требуется зарегистрировать динамически созданную конфигурацию или данные, которые должны жить в течение всего времени работы программы со ссылкой 'static.

Для этого существует метод Box::leak:

struct GlobalConfig {
    port: u16,
}

fn main() {
    let config = Box::new(GlobalConfig { port: 8080 });
    
    // Забирает владение Box<T> и возвращает ссылку на объект
    let static_ref: &'static mut GlobalConfig = Box::leak(config);
    
    static_ref.port = 9090;
}

3. Трейты Deref и DerefMut

#

Как сделать так, чтобы умный указатель ощущался в коде так же удобно, как обычная ссылка? Для этого в модуле std::ops предназначены типажи Deref и DerefMut.

При разыменовании *my_box Rust использует реализацию Deref, концептуально получая ссылку через my_box.deref().

use std::ops::{Deref, DerefMut};

struct MyBox<T>(T);

impl<T> Deref for MyBox<T> {
    type Target = T;
    
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

fn print_value(value: &i32) {
    println!("Значение: {value}");
}

fn main() {
    let boxed_val = MyBox(42);

    // Rust автоматически использует Deref для передачи ссылки
    print_value(&boxed_val);
}

4. Механизм Deref Coercion (Автоматическое приведение ссылок)

#

Мы реализовали Deref - и передача &MyBox<i32> в функцию, ожидающую &i32, сработала автоматически. Но как именно компилятор понимает, что одну ссылку можно передать вместо другой?

Здесь на сцену выходит механизм Deref Coercion. Если тип T реализует Deref<Target = U>, компилятор умеет автоматически приводить ссылки вида &T к ссылкам &U.

Важно подчеркнуть: Deref Coercion работает строго со ссылками, а не преобразует сам Box<T> по значению.

Три правила приведения ссылок:

#

1. Из &T в &U, если T: Deref<Target = U> (неизменяемая ссылка в неизменяемую).
2. Из &mut T в &mut U, если T: DerefMut<Target = U> (изменяемая ссылка в изменяемую).
3. Из &mut T в &U, если T: Deref<Target = U> (из изменяемой в неизменяемую).

Цепочки приведений (Chain Coercion)

#

Компилятор умеет применять Deref цепочкой несколько раз подряд. Рассмотрим тип Box<String>:

&Box<String>
    ↓ Deref
&String
    ↓ Deref
&str

Благодаря этой цепочке при передаче &Box<String> в функцию, принимающую &str, Rust прозрачно приведёт ссылки без явных вызовов:

fn print_greeting(name: &str) {
    println!("Привет, {name}!");
}

fn main() {
    let boxed_name = Box::new(String::from("Алексей"));
    
    // Автоматическая цепочка Deref Coercion: &Box<String> -> &String -> &str
    print_greeting(&boxed_name);
    
    // Благодаря Deref Rust умеет искать подходящие методы и у целевого типа:
    println!("Длина имени: {}", boxed_name.len());
}

Благодаря Deref Rust умеет искать подходящие методы и у целевого типа. Поэтому boxed_name.len() работает так же естественно, как вызов len() у String или str.

Давайте изучим эти механизмы на интерактивных слайдах:

 1struct SensorData {
 2    name: String,
 3}
 4
 5impl Drop for SensorData {
 6    fn drop(&mut self) {
 7        println!("Очистка ресурса датчика: {}", self.name);
 8    }
 9}
10
11fn main() {
12    {
13        let sensor = SensorData {
14            name: "Температура Кухни".to_string(),
15        };
16        println!("Работаем с датчиком: {}", sensor.name);
17    } // Здесь область видимости заканчивается - автоматически вызывается Drop!
18    println!("Секция завершена.");
19}
20

 1struct Config {
 2    port: u16,
 3}
 4
 5fn main() {
 6    // 1. Создаем объект в куче через Box
 7    let mut heap_config = Box::new(Config { port: 8080 });
 8    heap_config.port = 9090; // Мутабельный доступ к данным в куче
 9    println!("Порт конфигурации в куче: {}", heap_config.port);
10
11    // 2. Намеренно «утекаем» память для получения 'static ссылки
12    let static_config: &'static mut Config = Box::leak(heap_config);
13    static_config.port = 3000;
14    println!("Статический порт после Box::leak: {}", static_config.port);
15}
16

 1use std::ops::{Deref, DerefMut};
 2
 3struct SmartWrapper<T> {
 4    value: T,
 5}
 6
 7impl<T> SmartWrapper<T> {
 8    fn new(value: T) -> Self {
 9        SmartWrapper { value }
10    }
11}
12
13impl<T> Deref for SmartWrapper<T> {
14    type Target = T;
15    fn deref(&self) -> &Self::Target {
16        &self.value
17    }
18}
19
20impl<T> DerefMut for SmartWrapper<T> {
21    fn deref_mut(&mut self) -> &mut Self::Target {
22        &mut self.value
23    }
24}
25
26fn main() {
27    let mut wrapped_num = SmartWrapper::new(42);
28    
29    // Перегрузка оператора разыменования *
30    assert_eq!(*wrapped_num, 42);
31    
32    *wrapped_num += 10;
33    println!("Обновленное значение: {}", *wrapped_num);
34}
35

 1// Функция ожидает обычный строковый срез &str
 2fn print_message(msg: &str) {
 3    println!("Сообщение: {msg}");
 4}
 5
 6fn main() {
 7    let boxed_string: Box<String> = Box::new(String::from("Привет от Deref!"));
 8    
 9    // Цепочка приведений Deref Coercion: &Box<String> -> &String -> &str
10    print_message(&boxed_string);
11    
12    // Проверка методов целевого типа прямо через умный указатель:
13    println!("Длина строки: {}", boxed_string.len());
14}
15

Проверь свои знания!

#

Пройдите короткий тест, чтобы закрепить понимание идиомы RAII, работы Box<T>