Jak pracować z własnością w rdzy

W tym artykule zbadamy własność rdzy i jak to działa. Podejście własności i pożyczania jest stosunkowo nową konstrukcją i podróżuje nowi-beginnerom. W tym przewodniku spróbujemy zdemistyfikować, jak działa własność.

Co to jest własność?

Tradycyjnie istnieją dwa podstawowe sposoby zarządzania wspomnieniami. Pierwszym z nich to śmieci; Jest stosowany głównie w językach wysokiego poziomu, które abstrakcyjne koncepcję zarządzania pamięcią od programisty.

Drugi to „ręczne” zarządzanie pamięcią, w których programista wyraźnie definiuje użycie pamięci. Chociaż zapewnia kontrolę, pozostawia dużo miejsca na strzelanie w stopie.

Rust przyjmuje alternatywne podejście zwane własnością i pożyczaniem. Własność to nowy „konstrukt”, który określa wartość, ma właściciela.

Poniżej przedstawiono zasady własności w rdzy:

1. Każda wartość zdefiniowana w programie rdzy ma właściciela.
2. Wartość może mieć jednego właściciela na raz.
3. Wartość może żyć tylko tak długo, jak jego właściciel żyje. Co oznacza, że ​​właściciel nie został upuszczony.

Aby lepiej zrozumieć własność rdzy, omówmy kilka koncepcji i przykładów.

Zakres

Możemy zdefiniować zakres jako zakres, w którym żyje określona wartość. Zakres odgrywa ważną rolę we własności i pożyczaniu.

Każda zmienna jest związana jej zakresem. W tym przypadku zakres odnosi się do bloku, jak zamknięty przez parę kręconych aparatów ortodontycznych.

Rozważ następujący przykład program:

fn main ()
// zdefiniowane w zakresie funkcji głównej
Niech long_life = 100;

// zdefiniowane w bloku wewnętrznym (nowy zakres)
Niech Short_Life = 10;
println!(„Wewnętrzny zakres: ”, Short_Life);

// short_life nie istnieje w tym zakresie
println!(„Zewnętrzny zakres: ”, Short_Life);
println!(„Long Life: ”, Long_Life);

fn new_func ()
println!(„Funkcja Zakres: ”, Long_Life);

W poprzednim przykładowym programie mamy dwie funkcje: funkcję główną i funkcję new_func.

Wewnątrz głównej funkcji deklarujemy nową zmienną o nazwie Long_Life. Tworzymy również nowy zakres i deklarujemy nową zmienną o nazwie Short_Life.

Jeśli uruchomisz poprzedni kod, kompilator rdzy powie ci, że zmienne, Short_Life i Long_Life, nie istnieją w tym zakresie.

Wynika to z faktu, że zmienna Short_Life jest zadeklarowana w nowym zakresie. Po zakończeniu tego zakresu zmienna jest upuszczana. Oznacza to, że zmienna Short_Life nie istnieje poza kręconymi aparatami ortodontycznymi.

Ten sam przypadek dotyczy zmiennej Long_Life. Jest dostępny tylko w głównej funkcji. Próba dostępu do do niego w innej funkcji jest niedozwolona.

Sledzenie

Zmienne cieniowanie jest typowym przypadkiem. Odnosi się do funkcji, w której pierwsza deklaracja zmiennej jest „zastąpiona” lub zacieniona przez inną.

Weź następujący przykładowy kod:

fn main ()
Niech var1 = 10;
println!(„Przed Shadow: ”, var1);
// po cieniu
Niech var1 = 100;
println!(„After Shadow: ”, var1);

Tutaj mamy zmienną o nazwie Var1 ustawiona na 10. Następnie zacieniamy, deklarując zmienną o tej samej nazwie i ustawiamy ją na nową wartość.

To powinno wydrukować:

Uwaga: Nie myl cieńowania z mutubilnością. Sprawdź nasz samouczek na temat zmuszenia rdzy, aby dowiedzieć się więcej.

Przeniesienie własności

Rust pozwala nam przenieść własność wartości za pomocą operacji kopiowania lub przeniesienia. Weź następujący przykładowy kod:

fn main ()
Niech var1 = 10;
niech var2 = var1;
println!("var1: ", var1);
println!(„var2: ”, var2);

Poprzedni przykład deklaruje zmienną, var1, i przypisuje jej wartość 10. Zadeklarujemy również nową zmienną, var2, i przypisujemy ją do var1.

Kiedy tak się stanie, Rust utworzy nową kopię wartości i przypisuje ją do VAR2. Oznacza to, że obie zmienne nie mają wartości, a każda zajmuje własną przestrzeń pamięci.

Co się stanie, gdy próbujemy wykonać poprzednią operację o wartości o nieokreślonym rozmiarze pamięci?

Weźmy na przykład typ ciągu. Ponieważ może rosnąć lub kurczyć się, nie ma wcześniej określonej wielkości pamięci. Dlatego nie wdraża cechy kopii:

niech str1 = string :: z („hi”);
niech str2 = str1;
println!(„str1: ”, str1);
println!(„str1: ”, str2);

Uruchomienie tej samej operacji zmusza kompilator rdzy do przeniesienia wartości STR1 do STR2. Ponieważ wartość może mieć tylko jednego właściciela na raz, zmienna STR1 nie jest już ważna. Spowoduje to, że kompilator zwróci błąd, jeśli spróbujemy uzyskać do niego dostęp:

Wniosek

Jednym z powodów, dla których Rustacean uwielbiają język programowania rdzy, jest własność. Jest to nowa funkcja, która jednocześnie oferuje większą elastyczność i bezpieczeństwo. Zrozumienie, jak to działa, może być korzystne dla tworzenia szybkich i wydajnych aplikacji. Ponadto omówiono zasady własności i koncepcji. Mamy nadzieję, że ten artykuł jest pomocny. Sprawdź inne artykuły z Linux, aby uzyskać więcej wskazówek i informacji.