Learn Rust Coding · Урок

Модель владения в Rust

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

Урок 1 из 312 шагов

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

Что такое владение в Rust

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

Нет висячих указателей.
Нет ошибок двойного освобождения памяти.
Нет состязаний за данные в параллельном коде.

Эти правила проверяются во время компиляции!

Память стека и кучи

Программы используют две основные области памяти: стек и кучу.

Стек: быстрые данные фиксированного размера (например, целые числа, логические значения и типы известного размера). Данные добавляются и извлекаются в определённом порядке.
Куча: более медленные данные переменного размера (например, String, Vec). Память для данных запрашивается у распределителя и возвращается ему.

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

Правило 1: у каждого значения есть владелец

Первое правило владения простое: у каждого значения в Rust есть переменная, называемая его владельцем.

Представьте, что это этикетка на коробке. Переменная s ниже является владельцем текста "hello".

fn main() {
  let s = String::from("hello"); // s owns "hello"
  println!("{}", s);
}

Правило 2: одновременно существует только один владелец

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

Когда сложное значение (например, String, которое хранится в куче) присваивается от одной переменной другой, владение перемещается, а не копируется.

Передача владения на практике

Посмотрите, что происходит, когда значение s1 присваивается s2. Попробуйте запустить код.

fn main() {
  let s1 = String::from("Hello, CoddyKit!");
  let s2 = s1; // Ownership of the String data moves from s1 to s2

  // println!("{}", s1); // This line would cause a compile-time error!
  println!("{}", s2);
}

Понимание семантики «перемещения»

После выполнения let s2 = s1; переменная s1 больше не считается действительной. Rust не позволяет использовать s1 снова.

Это называется перемещением. Указатель, длина и ёмкость в стеке копируются, но сами данные в куче — нет.
Если бы s1 всё ещё была действительной, s1 и s2 попытались бы освободить одну и ту же область памяти при выходе из области видимости (это привело бы к ошибке двойного освобождения памяти).

Система владения Rust предотвращает это во время компиляции!

Владение и вызовы функций

Передача значения функции работает подобно присваиванию этого значения другой переменной: владение перемещается в функцию.

Когда функция завершается, владелец значения (параметр функции) выходит из области видимости, и значение удаляется.

Демонстрация владения в функциях

Обратите внимание, как значение String перемещается в takes_ownership, а затем gives_ownership возвращает новый String.

fn takes_ownership(some_string: String) {
  println!("Inside takes_ownership: {}", some_string);
} // some_string goes out of scope and `drop` is called.

fn gives_ownership() -> String {
  let some_string = String::from("returned string");
  some_string // Ownership is moved out of the function
}

fn main() {
  let s1 = String::from("hello");
  takes_ownership(s1); // s1's value moves into takes_ownership
  // println!("{}", s1); // Error: s1 is no longer valid here!

  let s2 = gives_ownership(); // s2 gets ownership of the returned String
  println!("After gives_ownership: {}", s2);
}

Правило 3: область видимости и удаление

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

Область видимости — это часть программы, в которой элемент является действительным; обычно она определяется фигурными скобками {}.
Когда переменная выходит из области видимости, Rust автоматически вызывает специальную функцию drop.

Это гарантирует автоматическую и безопасную очистку памяти без сборщика мусора.

Предотвращение ошибок памяти

Правила владения работают вместе, гарантируя безопасность памяти:

Один владелец: не позволяет разным частям кода пытаться освободить одну и ту же память.
Удаление при выходе из области видимости: гарантирует, что память освобождается ровно один раз и в нужный момент.

Во время компиляции это устраняет распространённые ошибки, такие как двойное освобождение памяти и обращение к уже освобождённой памяти, обеспечивая надёжность Вашей программы!

Проверка владения

Рассмотрите следующий код на Rust. Что произойдёт при попытке скомпилировать и запустить его?

fn main() {
  let message = String::from("Rust is fun!");
  let greeting = message;
  println!("{}", message);
}

Ответь в интерактивном уроке

Повторение: основы владения

Отличная работа! Вы изучили основные правила системы владения Rust:

У каждого значения есть владелец.
Одновременно может существовать только один владелец.
Когда владелец выходит из области видимости, значение удаляется.

Эта система предотвращает распространённые ошибки памяти без сборщика мусора. Далее мы рассмотрим заимствование, позволяющее совместно использовать данные без передачи владения.

Можно начать бесплатно

Изучай Rust с ИИ-репетитором — бесплатно

Пиши и запускай код прямо в браузере, получай мгновенную помощь от ИИ-репетитора 24/7 и продолжи учиться на сайте или в приложении.

Курсы: 39
Уроки: 144

Начать учиться бесплатно Посмотреть полный курс

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

Урок «Модель владения в Rust» бесплатный?

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

Чему я научусь в уроке «Модель владения в Rust»?

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

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

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

Сколько времени занимает урок «Модель владения в Rust»?

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

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

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

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

Модель владения в Rust
Объяснение ссылок и заимствования
Временные области действия для безопасных ссылок

← Назад к Learn Rust Coding