Learn Rust Coding · Урок

Взаимодействие с небезопасным Rust

Разберитесь, когда и как использовать блоки `unsafe` для обхода проверок безопасности Rust, обеспечивая работу с FFI и низкоуровневыми операциями над памятью.

«Взаимодействие с небезопасным Rust» — бесплатный урок Learn Rust Coding на CoddyKit. Это урок 3 из 3. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения Learn Rust Coding, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс Learn Rust Coding содержит 3 уроков всего.

Небезопасный Rust: введение

Добро пожаловать в небезопасный Rust! Хотя Rust известен своими гарантиями безопасности памяти, существуют ситуации, в которых может потребоваться обойти некоторые из этих проверок.

Ключевое слово unsafe в Rust позволяет сделать именно это. Это не способ писать «плохой» код, а инструмент для продвинутых случаев, когда требуется более прямой контроль над памятью или оборудованием.

Пять возможностей небезопасного кода

Используя блок unsafe, Вы получаете доступ к пяти специальным действиям, которые компилятор Rust обычно запрещает:

Разыменование необработанных указателей: Прямой доступ к адресам памяти.
Вызов небезопасных функций или методов: Выполнение функций с предварительными условиями, которые компилятор не может проверить.
Реализация небезопасных трейтов: Объявление того, что Ваш тип соблюдает определённые инварианты.
Доступ к изменяемым статическим переменным или их изменение: Глобальное совместное использование изменяемого состояния с риском состязаний за данные.
Доступ к полям union: Чтение из объединения, где тип может быть недействительным для текущих данных.

Разыменование необработанных указателей

Необработанные указатели — это адреса памяти без обычных гарантий безопасности Rust. Их можно создать из ссылок (&T, &mut T), но для их разыменования требуется блок unsafe.

Это означает, что именно Вы, программист, отвечаете за проверку допустимости указателя и того, что он указывает на выделенную память.

fn main() {
  let mut num = 5;
  let r1 = &num as *const i32; // Immutable raw pointer
  let r2 = &mut num as *mut i32; // Mutable raw pointer

  unsafe { // The `unsafe` block starts here
    println!("r1 points to: {}", *r1);
    *r2 = 10; // Modify data through mutable raw pointer
    println!("r2 points to: {}", *r2);
  } // The `unsafe` block ends here

  println!("Num is now: {}", num);
}

Вызов небезопасных функций

Некоторые функции помечены как unsafe fn. Это означает, что у функции есть предварительные условия, выполнение которых компилятор Rust не может гарантировать. Например, функция может ожидать допустимый адрес памяти, но не иметь возможности проверить его.

Вызов таких функций необходимо заключать в блок unsafe, показывая, что Вы, вызывающая сторона, обеспечиваете выполнение всех предварительных условий.

unsafe fn dangerous_operation() {
  println!("This operation could be dangerous if preconditions aren't met!");
}

fn main() {
  println!("Attempting a dangerous operation...");
  unsafe { // Calling an unsafe function requires `unsafe`
    dangerous_operation();
  }
  println!("Operation completed.");
}

Изменяемые статические переменные

По умолчанию Rust запрещает глобальное изменяемое состояние, чтобы избежать состязаний за данные. Однако Вы можете объявлять изменяемые статические переменные с помощью static mut.

Доступ к этим переменным или их изменение считаются unsafe, поскольку несколько потоков могут одновременно попытаться обратиться к ним, что приведёт к неопределённому поведению. Вы несёте ответственность за правильную синхронизацию.

static mut COUNTER: i32 = 0; // A mutable static variable

fn add_to_counter(inc: i32) {
  unsafe { // Modifying `static mut` requires `unsafe`
    COUNTER += inc;
  }
}

fn main() {
  add_to_counter(5);
  unsafe { // Reading `static mut` also requires `unsafe`
    println!("COUNTER after first add: {}", COUNTER);
  }

  add_to_counter(10);
  unsafe {
    println!("COUNTER after second add: {}", COUNTER);
  }
}

Реализация небезопасных трейтов

Некоторые трейты в Rust помечены как unsafe trait. Это означает, что при их реализации необходимо соблюдать определённые инварианты, которые компилятор не может проверить.

Распространённый пример — трейты Send и Sync, связанные с безопасностью потоков. Если Вы вручную реализуете unsafe trait, необходимо использовать unsafe impl Trait for Type и гарантировать свойства безопасности.

Большинство начинающих сталкиваются с этим нечасто, поскольку Rust обычно обрабатывает такие случаи автоматически или с помощью безопасных абстракций.

Доступ к полям объединения

union — это специальный тип, который в каждый момент может хранить значение *одного* из своих вариантов, причём все варианты используют одну и ту же область памяти. Он похож на объединения в C.

Для доступа к полю union требуется блок unsafe, поскольку компилятор не может знать, какое поле в данный момент активно. Чтение неактивного поля может привести к неопределённому поведению или неправильной интерпретации данных.

union Data {
  integer: u32,
  float: f32,
}

fn main() {
  let mut d = Data { integer: 42 }; // Initialize with an integer

  unsafe {
    // Accessing 'integer' is safe here
    println!("Integer value: {}", d.integer);

    // Accessing 'float' is unsafe, as 'integer' was initialized.
    // This would interpret the integer's bits as a float.
    // println!("Float value (unsafe): {}", d.float);
  }

  d.float = 3.14; // Now initialize with a float
  unsafe {
    // Accessing 'float' is safe now
    println!("Float value: {}", d.float);
  }
}

Практические случаи применения небезопасного кода

Хотя unsafe следует использовать умеренно, он необходим для нескольких продвинутых задач программирования:

Интерфейс внешних функций (FFI): Взаимодействие с кодом, написанным на других языках (например, с библиотеками C/C++).
Оптимизация производительности: Иногда обход проверок Rust может дать небольшой прирост производительности в критических участках (но сначала измерьте результат!).
Системное программирование низкого уровня: Написание операционных систем, драйверов устройств или программ для встраиваемых систем.
Создание безопасных абстракций: Реализация безопасных структур данных или интерфейсов программирования поверх небезопасных примитивов (например, то, как создаётся Vec).

Ваша ответственность при использовании небезопасного кода

Используя unsafe, Вы берёте на себя ответственность за ручное соблюдение гарантий безопасности Rust. Это означает следующее:

Обеспечивать действительность и правильное выравнивание памяти.
Предотвращать состязания за данные при работе с совместно используемым изменяемым состоянием.
Избегать висячих указателей и ошибок использования памяти после её освобождения.
Обеспечивать выполнение всех предварительных условий функций.

Неправильное использование unsafe может привести к неопределённому поведению — худшему виду ошибок, которые бывает очень сложно отлаживать.

Проверка знаний о небезопасном коде

Какое из следующих действий требует блока unsafe в Rust?

Повторение: небезопасный Rust

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

Помните, что unsafe не отключает полностью проверку заимствований, а лишь целиком передаёт Вам, программисту, ответственность за безопасность памяти и соблюдение инвариантов. Используйте его обдуманно и с особой осторожностью — обычно для FFI, низкоуровневой оптимизации или создания безопасных абстракций.

Часто задаваемые вопросы

Урок «Взаимодействие с небезопасным Rust» бесплатный?

Да — полный текст урока «Взаимодействие с небезопасным Rust» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс Learn Rust Coding, подпишись на CoddyKit PRO. Курс Learn Rust Coding содержит 3 уроков всего.

Чему я научусь в уроке «Взаимодействие с небезопасным Rust»?

Разберитесь, когда и как использовать блоки `unsafe` для обхода проверок безопасности Rust, обеспечивая работу с FFI и низкоуровневыми операциями над памятью. Ты практикуешь Learn Rust Coding с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать Learn Rust Coding?

Предыдущий опыт не требуется. Learn Rust Coding на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 3 из 3.

Сколько времени занимает урок «Взаимодействие с небезопасным Rust»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке Learn Rust Coding?

Да. Каждый урок Learn Rust Coding включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

← Назад к Learn Rust Coding