Языки программирования различаются тем, как они обрабатывают память и применяют правила управления памятью. Go и Python используют сборщики мусора, поэтому разработчики могут сосредоточиться на написании кода. C и C++ возлагают на программистов ответственность за управление памятью на более низком уровне.
Rust по-другому относится к управлению памятью, используя концепции, которые он называет владением и заимствованием. Он использует «проверку заимствования» для эффективного обеспечения безопасности памяти.
Что такое право собственности?
Владение — это функция и соглашение Rust, которое помогает обеспечить безопасность памяти программ без сборщика мусора. Это еще один способ борьбы проблема утечек памяти в вашем коде.
Компилятор Rust проверяет, соблюдает ли программа правила владения во время компиляции. Если программа следует этим правилам, она может работать. Если это не так, компилятор отказывается создавать исполняемый файл.
Rust проверяет правила владения с помощью одолжить чекер. Средство проверки заимствования проверяет модель владения и решает, является ли значение в памяти (
стек или куча) выходит за рамки или нет. Если значение выходит за рамки его области, оно недоступно для других частей программы, если только оно не заимствовано.Правила владения
В Rust каждая переменная имеет значение, которым она инициализирована, и может быть только один владелец. Как только владелец выходит за пределы области действия, значение отбрасывается. Важно понимать детали правил владения.
Первое правило владения состоит в том, что каждая переменная владеет своим инициализированным значением.
позволять владелец = Нить::от одного");
владелец переменная выше владеет строкой один и, в отличие от таких языков, как Python и Go, это значение будет удалено при переназначении переменной.
Второе правило владения состоит в том, что две переменные не могут указывать на одну и ту же ячейку памяти; каждое значение может иметь только одного владельца.
позволять новый_владелец = владелец;
новый владелец переменная теперь владеет значением, хранящимся в ячейке памяти владелец переменная. Если вы попытаетесь использовать владелец переменная, компилятор запаникует и откажется генерировать исполняемый файл.
В большинстве языков, использующих сборщики мусора, две переменные могут указывать на одно и то же место в памяти. Вот пример эквивалентного кода JavaScript:
позволять владелец = "владелец";
позволять новый_владелец = владелец;
приставка.log (новый_владелец);
Выполнение приведенного выше кода JavaScript работает без ошибок, и если вы сделаете то же самое в Go или Python, ваша программа тоже будет работать без ошибок.
Третье правило владения заключается в том, что как только переменная выходит за пределы объявленной области, значение удаляется, а память освобождается.
// переменная в отдельной области видимости
{
позволять пример = Нить::from("Вот новая область видимости");
}
Распечатать!("{}", пример)
Вы не можете получить доступ к пример переменная вне ее области видимости; попытка сделать это вызовет панику у компилятора.
Право собственности в функциях
Когда вы передаете значение функции в качестве аргумента, функция может получить доступ к этой переменной, даже если она не была объявлена в своей области видимости:
фнпринтер(ценность: Нить) -> Нить {
возвращаться ценность
}фнглавный() {
позволять х = Нить::from("Выводит значение"); // x владеет строковым значением
// здесь право собственности переходит к функции принтера
Распечатать!("{} Результат Печать X заключается в том, что это -:",printer(x));
}
Функция может получить доступ к этой переменной, потому что Rust передает право собственности на нее функции во время компиляции.
Вы можете подумать, что эту переменную можно использовать позже в исходной области видимости:
фнпринтер(ценность: Нить) -> Нить {
возвращаться ценность
}фнглавный() {
позволять х = Нить::from("Выводит значение");
Распечатать!("{} Результат Печать x заключается в том, что это -:",printer(x));
// Попытка использовать переменную после передачи права собственности на ее значение
распечатать!("{} не должно быть доступно", x)
}
Но если вы попытаетесь это сделать, компилятор запаникует и откажется создавать исполняемый файл:
Rust отдает приоритет повторному использованию кода
Повторное использование кода является важной практикой, но чтобы практиковать повторное использование кода, вам необходимо понимать правила владения Rust.
Rust — очень гибкий язык программирования. Он предоставляет такие концепции, как заимствование, перемещение, копирование и клонирование владения для повторного использования переменных.
