Destructor de óxido

El óxido proporciona un mecanismo para proporcionar limpieza en el montón. El rasgo de caída en óxido le permite ejecutar un "destructor" cuando ya no es necesario un valor. Un caso común es si un valor sale del alcance.

El destructor de óxido se compone de dos componentes:

1. Una llamada para soltar :: Drop Si el rasgo de caída se implementa por el tipo de valor.
2. Una caída generada automáticamente que llama recursivamente al destructor en el campo del valor. Esto elimina la necesidad de que sigas llamando al destructor.

Los tipos de óxido como caja, VEC, cadena, archivo y procesos implementan el rasgo de caída de forma predeterminada para liberar los recursos.

Implementación del rasgo de óxido

Veamos cómo podemos implementar un rasgo para un tipo personalizado.

La sintaxis para el rasgo de caída es como se muestra:

Rota de rasgo
fn Drop (& Mut Self);

Como se mencionó, Rust dejará automáticamente un valor si sale de alcance. Esto se hace en orden inverso de la creación.

Tome el ejemplo a continuación que implementa un rasgo de caída para un tipo personalizado.

usar std :: hilo;
use std :: tiempo :: duración;
structuser
nombre de usuario: & 'strat str,

Impl Drop for User
fndrop (& MutSelf)
println!("Dropping ", Self.nombre de usuario);


fnmain ()
// Alcance 1
Let _user1 = user UserName: "UserName1";

// Alcance 2
Let _user2 = user username: "username2";

// Alcance 3
Let _user3 = user username: "username3";
Sea _User4 = User UserName: "UserName4";
println!("Extitando el alcance 3");

println!("Alcance salido 3");
println!("------------------------------------------------ ");
// esperar
hilo :: dormir (duración :: from_millis (1500));
println!("Salir del alcance 2");

println!("Alcance salido 2");
println!("------------------------------------------------ ");
// Drop Variable manualmente
hilo :: dormir (duración :: from_millis (1500));
Drop (_User1);
println!("Cerrar la función principal!");
println!("------------------------------------------------ ");

Si ejecutamos el código anterior, deberíamos ver una salida como se muestra a continuación:

Expliquemos qué está haciendo el código anterior. Comenzamos definiendo un tipo personalizado utilizando una estructura. Tenga en cuenta que especificamos el campo de nombre de usuario para tener una vida estática.

A continuación, definimos un rasgo de caída para el tipo de usuario. Este es un rasgo de caída simple que simplemente se imprime en la consola cuando se deja caer una variable después de que sale de alcance.

En la función principal, creamos una instancia de la estructura del usuario llamada "User1".

Luego creamos dos bloques nuevos que contienen su propio alcance y definimos variables en cada alcance.

Tenga en cuenta el mensaje println que describe cuándo salimos de alcance y cuándo se suelta una variable.

También implementamos una duración del sueño para ilustrar el cambio entre ámbitos.

Finalmente, dejamos caer manualmente la variable en el alcance principal utilizando la función de caída como se define en el rasgo de caída.

Conclusión

Este breve artículo ilustra cómo implementar el rasgo de caída para los tipos personalizados y cómo funciona la caída cuando una variable sale de alcance.