Rust Smart Pointers

Ponteiros não são uma coisa nova para nenhum programador. Eles são um recurso que permite que você use variáveis ​​para armazenar um endereço na memória. O endereço então "aponta para", daí o ponteiro, para os dados armazenados nesse local.

Ponteiros inteligentes são ponteiros com recursos estendidos, como verificações ligadas e gerenciamento automático de memória. Ponteiros inteligentes também incluem metadados adicionais. Agora, o conceito de ponteiros inteligentes não é novo, especialmente para programadores C ++.

Para este artigo, exploraremos vários ponteiros inteligentes, conforme definido na Biblioteca Padrão Rust.

Pontos chave

Na ferrugem, os ponteiros inteligentes são estruturas de dados, no entanto, diferentemente das dicas normais, os ponteiros inteligentes podem realmente possuir dados. Eles são comumente implementados usando estruturas, mas diferem das estruturas normais, no sentido de que implementam Deref e Drop Traits.

Existem 5 dicas inteligentes para saber em Rust:

1. Caixa
2. Deref
3. Derrubar
4. Rc
5. Refcell

OBSERVAÇÃO: Em ferrugem refere -se ao tipo de dados.

Lembre -se de que não cobrirá todos os ponteiros inteligentes neste artigo.

Caixa

O ponteiro inteligente da caixa fornece uma maneira de fazer referência a dados armazenados na memória da heap. Por padrão, Rust aloca tudo na memória da pilha. Usando o ponteiro inteligente da caixa, podemos acessar dados na pilha, incorrendo em nenhuma sobrecarga de desempenho.

O ponteiro inteligente da caixa também obedece às regras de propriedade e empréstimos. Portanto, possui um único proprietário de dados e pode ter apenas uma referência mutável e qualquer número de referências imutáveis.

fn main ()
// Caixa
deixe var = box :: new (100);
println!("Valor: ", var)

No exemplo acima, temos um ponteiro inteligente de caixa que armazena o valor 5 na pilha. Lembre -se de que a caixa em si é armazenada na pilha.

Depois que o programa é encerrado, a caixa é desalocada da memória.

Deref

Como o nome sugere, o ponteiro Smart Deref é usado para permitir a manipulação da operação de desreferência. Usando o ponteiro Smart Deref, você pode criar uma estrutura que possa funcionar com ponteiro inteligente e referências.

Um código de exemplo é como mostrado abaixo:

Use std :: ops :: Deref;
Struct CustBox
Dados: t,

impl Deref para Custbox
// param de tipo genérico
Tipo de destino = t;
fn Deref (& self) -> & t
&auto.dados


fn main ()
Seja x = custbox data: 100;
println!("Valor: ",*(x.Deref ()))

Derrubar

O ponteiro Smart Drop é usado para a memória livre que é alocada na pilha. A característica de queda na ferrugem lida com a memória quando uma variável sai do escopo. Não precisamos chamar essa característica manualmente, pois a ferrugem fará isso por nós. No entanto, podemos implementá -lo para tipos personalizados, como mostrado.

estruturar mystruct
X: i32,

Impl Drop for MyStruct
fn gota (& mut eu)
println!("Droping: ", eu.x)


fn main ()
Seja _x = myStruct x: 100;
Seja _Y = myStruct x: 200;

O acima implementa a característica de queda para característica personalizada. A saída é como mostrado:

Droping: 200

Droping: 100

Conclusão

Neste artigo, abordamos como criar e trabalhar com ponteiros inteligentes comuns na linguagem de programação de ferrugem. Você pode aprender mais sobre Rust Smart Pointers no recurso abaixo:

https: // doc.Ferrute.org/livro/CH15-00-SMART Pointadores.html