Rust използва инструмент за проверка на заеми, за да наложи своите правила за собственост и да гарантира, че програмите са безопасни за паметта. Правилата за собственост диктуват как Rust управлява паметта върху стека и купчината.
Докато пишете програми на Rust, ще трябва да използвате променливи, без да променяте собствеността върху свързаната стойност. Rust предоставя стабилен механизъм за заемане, за да насърчи гъвкавостта и повторното използване на кода.
Какво е заемане в Rust?
Заемането е достъп до стойността на променлива без поемане на собственост върху променливата като се позовава на собственика. Проверката на заеми гарантира, че препратката е валидна и данните не се изпускат с помощта на конструкция, наречена lifetimes.
Животът е колко дълго съществува една променлива. Животът започва при създаване на променлива и завършва при унищожаване на променлива. Можете да заемете собствеността върху променлива и когато заетата референция е извън обхвата, собствеността се връща на променливата собственик. Заемането е малко като
указатели, които ще намерите в езици като C++ и Go. Но компилаторът Rust използва инструмента за проверка на заеми, за да гарантира, че програмите са безопасни за паметта.Пример за заемане в Rust
Можете да заемете собствеността върху променлива, като посочите собственика с помощта на символа амперсанд (&).
fnосновен() {
позволявам x = низ::от("здравей"); // x притежава "hello"
позволявам y = &x; // y препраща към x, заема "hello"
println!("{}", х);
println!("{}", y)
}
Без заемане чрез препратка, програмата ще изпадне в паника. Това би нарушило правилото за собственост, че една стойност може да има един собственик и две променливи не могат да сочат към едно и също място в паметта. Заемането може да бъде много полезно във функциите. Ето пример за заемане във функция, за да запазите собствеността, докато извиквате други функции, които приемат локални променливи като аргументи.
fnprint_even(vectr: &Vec<i32>) {
за стойности в vectr {
ако стойности % 2 == 0 {
println!("{}", стойности);
}
}
}
The print_even функцията препраща към вектор от 32-битови цели числа като свой аргумент. След това отпечатва редове със стойности, които са кратни на две във вектора, използвайки for-цикъл и println! макрос.
fnосновен() {
позволявам число_вектор = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
print_even(&номер_вектор); // собствеността е заета, не е преместена
println!("Основната функция запазва собствеността върху числовия вектор{:?}", number_vector)
}
Основната функция декларира променливата number_vector и й присвоява вектор от 32-битови цели числа. След това извиква функцията print_even и й предава препратка към число_вектор променлива с помощта на символа амперсанд.
Основната функция запазва собствеността върху число_вектор променлива, тя може да продължи да използва стойността в нейното място в паметта.
Заемане и мутиране на препратки
Функциите могат също така да променят заети променливи, като използват променливи препратки към тях, преди да върнат собствеността.
Въпреки това, за разлика от обикновените променливи, които могат да бъдат зададени като променливи с помощта на ключовата дума mut, вие трябва да префиксирате променливите препратки със символа амперсанд.
Преди да направите променливи препратки, променливата, която искате да модифицирате, трябва да бъде променлива.
fnпремахване_стойност(vectr: &мутVec<i32>) -> &Vec<i32> {
vectr.remove(4);
връщане вектр
}
The премахване_стойност функцията приема препратка към променлив вектор от 32-битови цели числа. Той връща вектор от 32-битови цели числа след премахване на стойността на вектора в четвъртия индекс.
fnосновен() {
позволяваммут числа = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
премахване_стойност(&мут числа); // променлива препратка тук
println!("{:?}", числа);
}
Функцията променя бройки вектор чрез извикване на remove_value и предаване на променливата препратка на вектор като аргумент. При отпечатване на вектора предходният четвърти индекс на вектора не съществува.
Забележете, че аргументът е препратка към променлив вектор.
Важно е да разберете собствеността и заемането
Ще трябва да разберете собствеността и заемането, за да напишете ефективен, безопасен за паметта Rust код, който се компилира и изпълнява. Ако вашият код не следва правилата за собственост, инструментът за проверка на заеми ще го открие. Ще трябва да направите вашата програма безопасна за паметта, за да може Rust да я компилира.
Проверката на заеми е досадна, когато сте нов в Rust. Но докато пишете повече Rust код, ще свикнете с него и ще придобиете опит в писането на безопасен за паметта Rust код.
