Destruidor de ferrugem

Rust fornece um mecanismo para fornecer limpeza na pilha. A característica de queda na ferrugem permite que você execute um "destruidor" quando um valor não é mais necessário. Um caso comum é se um valor sair do escopo.

O destruidor da ferrugem é composto por dois componentes:

1. Uma chamada para soltar :: Drop se a característica de queda for implementada pelo tipo de valor.
2. Uma queda gerada automaticamente que chama recursivamente o destruidor no campo do valor. Isso remove a necessidade de você continuar chamando o destruidor.

Tipos de ferrugem, como caixa, vec, string, arquivo e processos, implementam a característica de queda por padrão para libertar os recursos.

Implementando traço de queda de ferrugem

Vamos ver como podemos implementar uma característica para um tipo personalizado.

A sintaxe para traço de gota é como mostrado:

queda de característica
fn gota (& mut eu);

Como mencionado, a ferrugem soltará automaticamente um valor se sair do escopo. Isso é feito na ordem inversa da criação.

Veja o exemplo abaixo que implementa uma característica de queda para um tipo personalizado.

use std :: thread;
Use std :: time :: duração;
Structuser
nome de usuário: & 'static str,

Impl Drop for User
FNDROP (& MUMSELG)
println!("Dropping ", eu.nome de usuário);


fnmain ()
// Escopo 1
Seja _User1 = Usuário Nome de usuário: "UserName1";

// Escopo 2
Seja _User2 = Usuário Nome de usuário: "UserName2";

// Escopo 3
Seja _User3 = Usuário Nome de usuário: "UserName3";
Seja _User4 = Usuário Nome de usuário: "UserName4";
println!("Escopo 3");

println!("Escopo 3");
println!("------------------------------------------------ ");
// espere
thread :: Sleep (duração :: from_millis (1500));
println!("Escopo 2");

println!("Escopo 2");
println!("------------------------------------------------ ");
// soltar variável manualmente
thread :: Sleep (duração :: from_millis (1500));
soltar (_user1);
println!("Função principal fechar!");
println!("------------------------------------------------ ");

Se executarmos o código acima, devemos ver uma saída como mostrado abaixo:

Vamos explicar o que o código acima está fazendo. Começamos definindo um tipo personalizado usando uma estrutura. Observe que especificamos o campo de nome de usuário para ter uma vida estática.

Em seguida, definimos uma característica de queda para o tipo de usuário. Esta é uma característica simples que simplesmente imprime no console quando uma variável está sendo descartada depois que ela sai do escopo.

Na função principal, criamos uma instância da estrutura do usuário chamada "User1".

Em seguida, criamos dois novos blocos que contêm seu próprio escopo e definimos variáveis ​​em cada escopo.

Observe a mensagem println que descreve quando estamos saindo do escopo e quando uma variável é descartada.

Também implementamos uma duração do sono para ilustrar a mudança entre os escopos.

Finalmente, desativamos manualmente a variável no escopo principal usando a função de gota, conforme definido no traço de queda.

Conclusão

Este pequeno artigo ilustra como implementar a característica de queda para tipos personalizados e como a gota funciona quando uma variável sai do escopo.