Rust – Rasgo de gota

Drop trait nos permite personalizar lo que sucede cuando un valor está a punto de quedar fuera del alcance. El rasgo de caída es importante para el patrón de puntero inteligente. 

La funcionalidad de soltar rasgo se usa cuando se implementa un puntero inteligente. Por ejemplo, Box<T> personaliza Drop para desasignar el espacio en el montón al que apunta el cuadro.

El rasgo de caída se puede usar para limpiar valores cuando quedan fuera del alcance.

Sintaxis:

trait Drop {
fn drop(&mut self);
}

Las variables se descartan en el orden inverso al de su creación, por lo que d se eliminó antes que c. En Rust, el drop se activa automáticamente cuando nuestras instancias quedan fuera del alcance.

Con la ayuda de los ejemplos dados, será fácil entender cómo funciona el método drop:

Ejemplo 1:

struct SmartPointer {
 data: String,
}
  
// implementing Drop trait
impl Drop for SmartPointer {
 fn drop(&mut self) {
 println!("Dropping SmartPointer with data `{}`!", self.data);
 }
}
fn main() {
 let _c = SmartPointer { data: String::from("my stuff") };
 let _d = SmartPointer { data: String::from("other stuff") };
 println!("SmartPointers created.");
 }

Salida 1:

SmartPointers created.
Dropping SmartPointer with data `other stuff`!
Dropping SmartPointer with data `my stuff`!

Ejemplo 2:

struct New {
 data: String,
}
impl Drop for New {
 fn drop(&mut self) {
 println!("Dropping New with data `{}`!", self.data);
 }
}
fn main() {
 let c = New { data: String::from("some data") };
 println!("New created.");
 drop(c);
 println!("New dropped before the end of main.");
}

Salida 2:

New created.
Dropping New with data `some data`!
New dropped before the end of main.

Soltar un valor temprano con std::mem::drop

La función std::mem::drop no es lo mismo que el método drop en el rasgo Drop. Podemos llamarlo pasando el valor que queremos para soltar el valor antes del final del alcance. En Rust, no podemos llamar manualmente al método drop del atributo Drop, pero tenemos que llamar a la función std::mem::drop. 

Ejemplo:

struct GeeksforGeeks  
{  
  a : String,  
}  
impl Drop for GeeksforGeeks  
{  
  fn drop(&mut self)  
  {  
    println!("Dropping the instance of GeeksforGeeks with data : {}", self.a);  
  }  
}  
fn main()  
{  
  let value1 = GeeksforGeeks{a : String::from("This is ")};  
  drop(value1);  
  let _value2 = GeeksforGeeks{a: String::from("GFG Platform")};  
  
}

En el ejemplo anterior, llamamos al método drop() manualmente. El compilador de Rust arroja un error que no nos permite llamar al método drop() explícitamente. En lugar de llamar explícitamente al método drop(), llamamos a la función std::mem::drop para eliminar el valor antes de que salga del alcance.

La sintaxis de la función std::mem::drop es diferente de la función drop() definida en el atributo Drop. La función std::mem::drop contiene el valor pasado como argumento que se descartará antes de que salga del alcance.

Producción:

Dropping the instance of GeeksforGeeks with data : This is 
Dropping the instance of GeeksforGeeks with data : GFG Platform