Rdza niszczyciel

Rdza stanowi mechanizm zapewniający czyszczenie na stosie. Cecha spadku rdzy pozwala uruchomić „destruktor”, gdy wartość nie jest już potrzebna. Wspólnym przypadkiem jest to, że wartość wychodzi z zakresu.

Zniszcznik rdzy składa się z dwóch komponentów:

1. Wezwanie do upuszczania :: Jeśli cecha upuszczania jest zaimplementowana według typu wartości.
2. Automatycznie generowany kropla, która rekurencyjnie nazywa destruktora na polu wartości. To usuwa potrzebę, abyś wzywał destruktora.

Typy rdzy, takie jak pudełko, VEC, ciąg, pliki i procesy domyślnie wdrażają cechę upuszczania, aby uwolnić zasoby.

Wdrażanie cechy kropli rdzy

Zobaczmy, jak możemy zaimplementować cechę dla typu niestandardowego.

Składnia cechy upuszczenia jest jak pokazana:

Drop cechy
FN Drop (& Mut Self);

Jak wspomniano, rdza automatycznie zrzuci wartość, jeśli zniknie z zakresu. Odbywa się to w odwrotnej kolejności tworzenia.

Weźmy przykład poniżej, który implementuje cechę upuszczania dla typu niestandardowego.

Użyj std :: wątek;
Użyj std :: czas :: czas trwania;
structuser
Nazwa użytkownika: & 'static Str,

Imp Drop dla użytkownika
fndrop (& mutself)
println!(„Upuszczanie ”, jaźń.nazwa użytkownika);


fnmain ()
// Zakres 1
niech _user1 = użytkownik nazwa użytkownika: „nazwa użytkownika1”;

// Zakres 2
let _user2 = użytkownik nazwa użytkownika: „nazwa użytkownika2”;

// Zakres 3
let _user3 = użytkownik nazwa użytkownika: „nazwa użytkownika3”;
let _user4 = użytkownik nazwa użytkownika: „nazwa użytkownika4”;
println!(„Zakres wyjścia 3”);

println!(„Zakresy wyjściowe 3”);
println!(„------------------------------------------------- ");
// Czekać
wątek :: Sleep (czas trwania :: from_millis (1500));
println!(„Zakres wyjścia 2”);

println!(„Zakresy wyjściowe 2”);
println!(„------------------------------------------------- ");
// upuść zmienną ręcznie
wątek :: Sleep (czas trwania :: from_millis (1500));
upuść (_User1);
println!(„Główna funkcja blisko!");
println!(„------------------------------------------------- ");

Jeśli uruchomimy powyższy kod, powinniśmy zobaczyć wyjście, jak pokazano poniżej:

Wyjaśnijmy, co robi powyższy kod. Zaczynamy od zdefiniowania typu niestandardowego za pomocą struktury. Zauważ, że określamy pole nazwy użytkownika, aby mieć statyczny okres życia.

Następnie definiujemy cechę upuszczania dla typu użytkownika. Jest to prosta cecha, która po prostu drukuje do konsoli, gdy zmienna jest upuszczana.

W głównej funkcji tworzymy instancję struktury użytkownika o nazwie „User1”.

Następnie tworzymy dwa nowe bloki, które zawierają własny zakres i definiują zmienne w każdym zakresie.

Zwróć uwagę na wiadomość, która opisuje, kiedy wychodzimy z zakresu i po upuszczeniu zmiennej.

Wdrażamy również czas snu, aby zilustrować przełączanie między zakresem.

Wreszcie, ręcznie upuszczamy zmienną w głównym zakresie za pomocą funkcji upuści.

Wniosek

Ten krótki artykuł ilustruje, jak zaimplementować cechę upuszczania typów niestandardowych i jak działa kropla, gdy zmienna nie ma zakresu.