Pożyczanie rdzy i odniesienia

Każda wartość w rdzy ma zmienną znaną jako jej właściciel. Rust pojedyncza zasada własności stwierdza, że ​​może być tylko jeden właściciel na raz.

Możemy jednak napotkać przypadki, w których musimy używać i tymczasowo modyfikować wartość. Możemy to osiągnąć za pomocą pożyczek. Pożyczanie to koncepcja, która pozwala nam pożyczyć wartość, używać jej, a kiedy już skończymy, zwrócić ją do swojego właściciela w tym samym stanie. Oznacza to, że pożyczka nie zmienia pierwotnej wartości.

Pożyczamy wartość, odwołując się do jej za pomocą adresu pamięci i i operatora. Następnie możemy przekazać odniesienie do funkcji i użyć wartości, jak uważamy za dopasowanie.

Zasady odniesienia

Istnieją dwie zasady pracy z odniesieniami w rdzy:

1. Możesz mieć zmienne referencje lub wiele niezmiennych referencji jednocześnie.
2. Wszystkie odniesienia muszą być ważne.

Odniesienie rdzy i wartość pożyczki

W rdzy używamy i operatora do odniesienia adresu wartości. Przykładowy kod jest pokazany poniżej:

fn main ()
niech String = String :: z („hello”);
niech str_len = get_str_length (& string);
println!(„String Długość: ”, str_len);

fn get_str_length (string: & string) -> usize
powrót ciąg.len ();

W powyższym kodzie definiujemy zmienną o nazwie „String”. Zgodnie z zasadami własności ta zmienna jest właścicielem wartości „Hello”.

Musimy jednak użyć tej zmiennej w funkcji. Ponieważ wartość może mieć właściciela tylko w danym momencie, użycie go wewnątrz funkcji przeniesie własność. Ponieważ nie chcemy, aby własność została przeniesiona do funkcji, pożyczamy wartość za pomocą, odwołując się do właściciela.

Zauważ, że dodajemy i operator w typu parametru funkcji. To mówi Rust, że odwołujemy się do wartości i powinniśmy ją oddać po zakończeniu.

Zmienione odniesienia

Jeśli spróbujemy zmienić pożyczoną wartość, Rust spowoduje błąd. Weź poniższy przykład:

fn main ()
niech String = String :: z („hello”);
zmiana_value (i ciąg);

fn zmiana_value (String: & String)
strunowy.push_str („świat!")

Uruchomienie powyższego kodu powinno zwrócić błąd jako:

Dzieje się tak, ponieważ odniesienia są domyślnie niezmienne. Stąd nie możemy zmodyfikować pożyczonej wartości.

Możemy mieć zmienne odniesienie, które pozwala nam zmodyfikować pożyczoną wartość. Rozważ przykładowy kod poniżej:

fn main ()
Let Mut String = String :: From („Hello”);
zmiana_value (& MUT String);

fn zmiana_value (String: & Mut String)
strunowy.push_str („świat!")

W powyższym przykładzie ustawiamy zmienną „String” T być zmienna. Następnie tworzymy zmienne odniesienie za pomocą ciągu & mut w wywołaniu funkcji. Zauważ, że parametr funkcji akceptuje zmienne odniesienie, umożliwiając funkcję zmianę pożyczonej wartości.

Uwaga: Jak wspomniano, możesz mieć tylko jedno zmienne odniesienie w określonym czasie. Próba utworzenia więcej niż jednego zmiennego odniesienia wywoła błąd, jak pokazano:

fn main ()
Let Mut String = String :: From („Hello”);
Niech String2 = & Mut String;
Niech String3 = & Mut String;
println!(" ", string2, string3);

fn zmiana_value (String: & Mut String)
strunowy.push_str („świat!")

Kod powyżej powinien zwrócić błąd, jak pokazano:

Ta funkcja może pomóc w zapobieganiu warunkom wyścigu przy wartościach pożyczania i odwołania.

Wniosek

Ten artykuł zawiera podstawowe zrozumienie używania i pracy z funkcjami pożyczania rdzy i odniesienia. Możesz sprawdzić dokumenty, aby dalej odkrywać.