Destructeur de rouille

La rouille fournit un mécanisme pour fournir un nettoyage sur le tas. Le trait de chute de Rust vous permet d'exécuter un «destructeur» lorsqu'une valeur n'est plus nécessaire. Un cas commun est si une valeur est hors de portée.

Le destructeur de la rouille est composé de deux composants:

1. Un appel à Drop :: Drop si le trait de dépôt est implémenté par le type de valeur.
2. Une goutte générée automatiquement qui appelle récursivement le destructeur sur le terrain de la valeur. Cela supprime le besoin pour vous de continuer à appeler le destructeur.

Les types de rouille tels que Box, Vec, String, Fichier et les processus implémentent le trait de dépôt par défaut pour libérer les ressources.

Implémentation de trait de chute de rouille

Voyons comment nous pouvons implémenter un trait pour un type personnalisé.

La syntaxe pour le trait de drop est comme indiqué:

Trait Drop
fn drop (& mut self);

Comme mentionné, Rust baissera automatiquement une valeur si elle sort de portée. Cela se fait dans l'ordre inverse de la création.

Prenez l'exemple ci-dessous qui met en œuvre un trait de chute pour un type personnalisé.

Utilisez Std :: Thread;
Utilisez Std :: Time :: durée;
Structureur
Nom d'utilisateur: & 'statique Str,

implp drop pour l'utilisateur
fndrop (& metfref)
println!("Abandonner ", soi.nom d'utilisateur);


fnmain ()
// Portée 1
Selt _user1 = user username: "username1";

// Portée 2
Selt _user2 = user username: "username2";

// Scope 3
Selt _user3 = user username: "username3";
Selt _user4 = user username: "username4";
println!("Sortissage de la lunette 3");

println!("EXIDIT SCOPE 3");
println!("------------------------------------------------ ");
// attendez
thread :: sleep (durée :: from_millis (1500));
println!("Sortissage de la lunette 2");

println!("EXIDIT SCOPE 2");
println!("------------------------------------------------ ");
// Déposez la variable manuellement
thread :: sleep (durée :: from_millis (1500));
drop (_user1);
println!("Fonction principale Close!");
println!("------------------------------------------------ ");

Si nous exécutons le code ci-dessus, nous devrions voir une sortie comme indiqué ci-dessous:

Expliquons ce que fait le code ci-dessus. Nous commençons par définir un type personnalisé à l'aide d'une structure. Notez que nous spécifions le champ de nom d'utilisateur pour avoir une durée de vie statique.

Ensuite, nous définissons un trait de dépôt pour le type d'utilisateur. Il s'agit d'un simple trait de dépôt qui imprime simplement à la console lorsqu'une variable est abandonnée après sa portée.

Dans la fonction principale, nous créons une instance de la structure utilisateur appelée «User1».

Nous créons ensuite deux nouveaux blocs qui contiennent leur propre portée et définissons les variables dans chaque portée.

Notez le message println qui décrit lorsque nous sortons de la portée et lorsqu'une variable est abandonnée.

Nous mettons également en œuvre une durée de sommeil pour illustrer le commutateur entre les lunettes.

Enfin, nous supprimons manuellement la variable dans la portée principale en utilisant la fonction de dépôt telle que définie dans le trait de dépôt.

Conclusion

Ce court article illustre comment implémenter le trait de dépôt pour les types personnalisés et comment le dépôt fonctionne lorsqu'une variable est hors de portée.