Интелигентни указатели в Rust: Как работят?

Управлението на паметта е една от предимствата на Rust, особено след като безопасността не е компрометирана. Системата за собственост на Rust позволява на компилатора да гарантира безопасността на кода и свободата от грешки в паметта като висящи указатели и изтичане на памет.

Rust също предоставя интелигентни указатели с допълнителни метаданни и възможности извън традиционните указатели. Интелигентните указатели са удобни за справяне с изтичане на памет.

Какво представляват интелигентните указатели в Rust?

Интелигентните указатели са един от Типове данни на Rust който разширява възможностите на обикновените указатели, като предлага допълнителни функционалности като претоварени оператори, деструктори и автоматично управление на паметта.

Rust използва структури за изпълнение на интелигентни указатели; по този начин интелигентните указатели също имат способности за собственост.

Когато свържете памет, съдържаща динамично разпределени данни, с интелигентни указатели, те автоматично се освобождават. Интелигентните указатели осигуряват функционалност за контролиране на Животът на обекта на Rust, което ги прави удобни за предотвратяване на грешки като дерефериране на нулев указател и изтичане на памет, които са популярни в други езици на ниско ниво като C и C++.

Ползи от използването на интелигентни указатели

Ето някои предимства от използването на интелигентни указатели:

1. Автоматично управление на паметта: Интелигентните указатели осигуряват автоматично управление на паметта, включително заделяне и освобождаване, за разлика от ръчното управление на паметта с обикновени указатели.
2. Подобрена безопасност: Интелигентните указатели налагат семантиката на собствеността, като гарантират, че само един собственик може да има достъп до ресурси наведнъж, предотвратявайки проследяване на данни и грешки, свързани с паралелността.
3. Гъвкавост: Rust предоставя множество интелигентни указатели, всеки със свой набор от семантика на собствеността за гъвкаво писане на безопасен код.
4. Управление на ресурси: Можете да използвате интелигентни указатели, за да управлявате други ресурси като манипулатори на файлове и мрежови сокети, като капсулирате ресурсите в рамките на интелигентен показалец, който улеснява управлението на техния жизнен цикъл и гарантира, че те са правилно затворени и освободени след това използване.
5. Подобрена производителност: Интелигентните указатели спомагат за подобряване на производителността чрез намаляване на копирането и разпределенията на паметта – намаленият отпечатък на паметта от използването на интелигентни указатели води до повишена производителност.

Интелигентните указатели са подходящи за средни до големи приложения, особено в случаите, когато управлението на паметта е критично.

Видове интелигентни указатели

Rust предоставя множество видове интелигентни указатели, включително Кутия, Rc, RefCell, и Mutex.

1. The Box Smart Pointer

The Кутия Smart Pointer е най-простият и най-разпространеният интелигентен показалец на Rust. The Кутия интелигентният указател помага за разпределяне на стойности в купчината и създава указател в кутия за достъпност.

The Кутия Smart Pointer е удобен за динамично разпределение на памет, когато трябва да гарантирате, че паметта се освобождава автоматично, когато указателите са извън обхвата.

Ето как можете да декларирате и използвате a Кутия показалец:

fnосновен(){
// нов екземпляр на интелигентния указател на кутията 
позволявам x = Кутия::ново(5);
println!(х)
}

The Кутия type е част от прелюдията на Rust, така че няма да се налага да импортирате типа, за разлика от други интелигентни указатели.

The х променливата е a Кутия указател, сочещ към 5 целочислена стойност. Rust разпределя паметта за стойността в купчината и автоматично освобождава, когато променливата е извън обхвата.

2. Rc Smart Pointer

The Rc (Reference Counted) интелигентният показалец предоставя функционалност за създаване на стойности на споделена собственост. The Rc интелигентните указатели проследяват броя на препратките към дадена стойност и освобождават стойността, когато последната препратка е извън обхвата.

The Rc интелигентният показалец е удобен, когато трябва да споделите собствеността върху стойност за достъпност в множество части на вашата програма.

За да декларирате Rc интелигентен показалец, ще импортирате Rc struct от стандартната библиотека, декларирайте нов Rc показалец с нов функция и клонирайте променливата на указателя с клонинг променлива.

използване std:: rc:: Rc;
fnосновен() {
// нов екземпляр на интелигентния указател RC 
позволявам x = Rc:: нов(5);
позволявам y = Rc:: клонинг (&x);
println!("x = {}, y = {}", x, y);
}

The х променливата е Rc указателна променлива и г променливата е клонинг с достъп до стойността в паметта. Броят на препратките е две и стойността се освобождава от паметта, когато променливите са извън обхвата.

3. Смарт показалецът RefCell

The RefCell интелигентният указател осигурява вътрешна променливост, която позволява неизменни и променливи препратки да съществуват едновременно, докато има една променлива препратка за даден момент.

The RefCell интелигентният показалец е удобен при мутиране на стойности, притежавани от променливи препратки.

The Refcell функцията не е част от прелюдията на Rust, така че ще трябва да импортирате структурата от стандартната библиотека, за да използвате интелигентния указател.

използване std:: клетка:: RefCell;
fnосновен(){
// нов екземпляр на интелигентния указател Refcell 
позволявам x = RefCell:: нов(5);
позволявам y = x.borrow();
позволявам z = x.borrow_mut();
println!("y = {}", *y);
println!("z = {}", *z);
} 

The Refcell интелигентният указател съдържа стойността и г променливата е неизменната препратка към стойността. The borrow_mut функцията създава променлива препратка към стойността.

Програмата е безопасна, ако има само една променлива препратка в даден момент.

4. Смарт показалецът Mutex

The Mutex интелигентният показалец осигурява взаимно изключване. The Mutex интелигентният показалец е удобен за синхронизиране на достъпа до стойности в множество нишки в едновременни програми.

The Mutex интелигентният указател осигурява взаимно изключване, за да се гарантира, че само една нишка има достъп до стойността, като същевременно предотвратява проследяването на данни.

Ще трябва да импортирате Mutex структурирайте и създайте нов екземпляр с нов функция за използване Mutex Интелигентен показалец в Rust.

използване std:: sync:: Mutex;
fnосновен() {
// нов екземпляр на указателя на mutex 
позволявам брояч = Mutex:: нов (0);
 {
позволяваммут num = counter.lock().unwrap();
 *брой += 1;
 }
println!(„Резултат: {}“, *counter.lock().unwrap());
}

The брояч променливата е новото Mutex инстанция. The основен функция придобива заключване на mutex с ключалка метод на Mutex инстанция. Заключването позволява безопасно модифициране на стойността на брояча, преди да освободите заключването и да отпечатате стойността.

The Mutex тип гарантира, че само една нишка има достъп до споделените ресурси (в този случай, the брояч променлива) и променяйте стойността му наведнъж. Взаимното изключване гарантира, че едновременният достъп до споделените ресурси е сериализиран, за да се предотвратят следи на данни и други проблеми с паралелността.

Моделът на собственост на Rust гарантира безопасност на паметта

Интелигентните указатели са един от подходите на Rust за безопасност и гъвкавост на паметта. Моделът на собственост на Rust гарантира, че програмите използват безопасно паметта с инструмента за проверка на заеми по време на компилиране.

Проверката на заеми е ключова характеристика на модела на собственост на Rust, който налага строги правила за достъпност и модификация на паметта.