`mem::drop` în Rust

std::mem: mutare, înlocuire, dimensiuni Rust 1.0

Distruge o valoare imediat, înainte de sfârșitul blocului: eliberează memoria, închide fișierul, deblochează mutex-ul.

Sintaxă

pub fn drop<T>(_x: T)

Ce face `mem::drop`

Rust distruge automat fiecare valoare când proprietarul ei iese din domeniu. drop(x) îți permite să faci asta mai devreme: funcția primește valoarea (o mută) și nu face nimic cu ea, așa că valoarea este distrusă la finalul apelului, iar codul din Drop rulează atunci.

Cazuri tipice: eliberezi un MutexGuard ca să permiți altor fire accesul, închizi un fișier sau un Sender, termini un împrumut RefCell. drop este în prelude, deci nu ai nevoie de use std::mem. Nu poți apela direct metoda x.drop().

Parametri

Parametru	Descriere
`_x`	Valoarea distrusă.

Ce returnează

Nimic.

Exemple

Exemplul 1: Ordinea distrugerii

Fără drop, valorile sunt distruse la sfârșitul lui main, în ordinea inversă creării. drop(a) o distruge pe a imediat.

struct Conexiune(&'static str);

impl Drop for Conexiune {
    fn drop(&mut self) {
        println!("închid conexiunea {}", self.0);
    }
}

fn main() {
    let a = Conexiune("Iași");
    let _b = Conexiune("Cluj");
    let _c = Conexiune("Timișoara");

    drop(a);
    println!("lucrez în continuare...");
    println!("sfârșitul lui main");
}

Rezultat

închid conexiunea Iași
lucrez în continuare...
sfârșitul lui main
închid conexiunea Timișoara
închid conexiunea Cluj

Exemplul 2: Eliberarea unui lacăt

După drop(g), mutex-ul este liber și try_lock reușește.

use std::sync::Mutex;

fn main() {
    let stoc = Mutex::new(10);

    let mut g = stoc.lock().unwrap();
    *g -= 3;
    println!("liber în timp ce țin lock-ul: {}", stoc.try_lock().is_ok());
    drop(g);
    println!("liber după drop: {}", stoc.try_lock().is_ok());
    println!("stoc: {}", stoc.lock().unwrap());
}