Rust Destructor

Rust fornisce un meccanismo per fornire la pulizia sul mucchio. Il tratto di caduta in ruggine ti consente di eseguire un "distruttore" quando non è più necessario un valore. Un caso comune è se un valore esce dall'ambito.

Il Rust Destructor è composto da due componenti:

1. Una chiamata a drop :: drop se il tratto di caduta è implementato dal tipo di valore.
2. Una goccia generata automaticamente che chiama ricorsivamente il distruttore sul campo del valore. Questo rimuove la necessità di continuare a chiamare il distruttore.

Tipi di ruggine come box, vec, stringa, file e processi implementano il tratto di caduta per impostazione predefinita per liberare le risorse.

Implementazione del tratto di drop di ruggine

Vediamo come possiamo implementare un tratto per un tipo personalizzato.

La sintassi per il tratto di caduta è come mostrato:

tratto drop
fn drop (& mut self);

Come accennato, la ruggine eliminerà automaticamente un valore se uscirà dall'ambito. Questo viene fatto in ordine inverso della creazione.

Prendi un esempio di seguito che implementa un tratto di caduta per un tipo personalizzato.

Usa std :: thread;
Usa std :: time :: durata;
StrucTuser
Nome utente: & 'static STR,

Impl Drop per l'utente
fndrop (& mutself)
println!("Droping ", self.nome utente);


fnMain ()
// Scope 1
let _user1 = user nome utente: "nome utente1";

// Scope 2
let _user2 = user nome utente: "nome utente2";

// Scope 3
let _user3 = user nome utente: "nome utente3";
let _user4 = user nome utente: "nome utente4";
println!("Exciting Scope 3");

println!("Ambito uscito 3");
println!("-------------------------------------------------------- ");
// Aspettare
Discussione :: sleep (durata :: from_millis (1500));
println!("Exciting Scope 2");

println!("Ambito uscito 2");
println!("-------------------------------------------------------- ");
// Fai cadere manualmente la variabile
Discussione :: sleep (durata :: from_millis (1500));
drop (_user1);
println!("Funzione principale Close!");
println!("-------------------------------------------------------- ");

Se eseguiamo il codice sopra, dovremmo vedere un output come mostrato di seguito:

Spiegiamo cosa sta facendo il codice sopra. Iniziamo definendo un tipo personalizzato usando una struttura. Si noti che specifichiamo il campo Nome utente per avere una vita statica.

Successivamente, definiamo un tratto di caduta per il tipo di utente. Questo è un semplice tratto di caduta che sta semplicemente stampa sulla console quando una variabile viene lasciata cadere dopo che è uscita dall'ambito.

Nella funzione principale, creiamo un'istanza della struttura utente chiamata "user1".

Creiamo quindi due nuovi blocchi che contengono il proprio ambito e definiamo variabili in ciascun ambito.

Nota il messaggio println che descrive quando stiamo passando per portata e quando viene eliminata una variabile.

Implementiamo anche una durata del sonno per illustrare il passaggio tra le scope.

Infine, eliminiamo manualmente la variabile nell'ambito principale usando la funzione di caduta come definito nel tratto di caduta.

Conclusione

Questo breve articolo illustra come implementare il tratto di caduta per i tipi personalizzati e come funziona il calo quando una variabile passa dall'ambito.