Os ponteiros inteligentes têm vantagens adicionais sobre os ponteiros comuns. Aqui está tudo o que você precisa saber sobre ponteiros inteligentes no Rust.
O gerenciamento de memória é um dos pontos de venda do Rust, especialmente porque a segurança não é comprometida. O sistema de propriedade do Rust permite que o compilador garanta a segurança do código e a isenção de erros de memória, como ponteiros pendentes e vazamentos de memória.
O Rust também fornece ponteiros inteligentes com metadados e recursos adicionais além dos ponteiros tradicionais. Ponteiros inteligentes são úteis para lidar com vazamentos de memória.
O que são ponteiros inteligentes em Rust?
Os ponteiros inteligentes são um dos Tipos de dados do Rust que estende os recursos de ponteiros regulares, oferecendo funcionalidades adicionais, como operadores sobrecarregados, destruidores e gerenciamento automático de memória.
Rust utiliza structs para executar ponteiros inteligentes; assim, os ponteiros inteligentes também têm recursos de propriedade.
Quando você vincula a memória que contém dados alocados dinamicamente com ponteiros inteligentes, eles são desalocados automaticamente. Ponteiros inteligentes fornecem funcionalidade para controlar o Tempo de vida do objeto Rust, tornando-os úteis para evitar erros como desreferenciação de ponteiro nulo e vazamentos de memória que são populares em outras linguagens de baixo nível, como C e C++.
Benefícios do uso de ponteiros inteligentes
Aqui estão alguns benefícios do uso de ponteiros inteligentes:
- Gerenciamento Automático de Memória: os ponteiros inteligentes fornecem gerenciamento automático de memória, incluindo alocação e desalocação, em contraste com o gerenciamento manual de memória com ponteiros regulares.
- Segurança aprimorada: os ponteiros inteligentes reforçam a semântica de propriedade, garantindo que apenas um proprietário possa acessar recursos por vez, evitando rastreamentos de dados e bugs relacionados à simultaneidade.
- Flexibilidade: Rust fornece vários ponteiros inteligentes, cada um com seu conjunto de semântica de propriedade para escrever código seguro de forma flexível.
- Gestão de recursos: você pode usar ponteiros inteligentes para gerenciar outros recursos, como manipuladores de arquivos e soquetes de rede, encapsulando os recursos dentro de um ponteiro inteligente que facilita o gerenciamento de seu ciclo de vida e garante que eles sejam fechados e liberados corretamente após usar.
- Performance melhorada: os ponteiros inteligentes ajudam a melhorar o desempenho, reduzindo a cópia e as alocações de memória — a redução do consumo de memória devido ao uso de ponteiros inteligentes resulta em maior desempenho.
Os ponteiros inteligentes são adequados para aplicativos de médio a grande porte, especialmente nos casos em que o gerenciamento de memória é crítico.
Tipos de ponteiros inteligentes
Rust fornece vários tipos de ponteiros inteligentes, incluindo Caixa, Rc, RefCell, e mutex.
1. O ponteiro inteligente da caixa
O Caixa O Smart Pointer é o ponteiro inteligente mais simples e comum do Rust. O Caixa O ponteiro inteligente ajuda a alocar valores na pilha e cria um ponteiro em caixa para acessibilidade.
O Caixa O Smart Pointer é útil para alocação dinâmica de memória quando você precisa garantir que a memória seja desalocada automaticamente quando os ponteiros estiverem fora do escopo.
Veja como você pode declarar e usar um Caixa ponteiro:
fnprincipal(){// nova instância do ponteiro inteligente da caixa
deixar x = Caixa::novo(5);
println!(x)
}
O Caixa O tipo faz parte do prelúdio do Rust, então você não terá que importar o tipo, ao contrário de outros ponteiros inteligentes.
O x variável é um Caixa ponteiro apontando para o valor de 5 inteiros. Rust aloca a memória para o valor no heap e desaloca automaticamente quando a variável está fora do escopo.
2. O Ponteiro Inteligente Rc
O Rc O ponteiro inteligente (contado por referência) fornece funcionalidade para criar valores de propriedade compartilhada. O Rc ponteiros inteligentes rastreiam o número de referências a um valor e desalocam o valor quando a última referência está fora do escopo.
O Rc O ponteiro inteligente é útil quando você precisa compartilhar a propriedade de um valor para acessibilidade em várias partes do seu programa.
Para declarar um Rc ponteiro inteligente, você importará o Rc struct da biblioteca padrão, declare um novo Rc ponteiro com o novo função e clone a variável de ponteiro com o clone variável.
usar padrão:: rc:: Rc;fnprincipal() {
// nova instância do ponteiro inteligente RC
deixar x = Rc:: novo(5);
deixar y = Rc:: clone(&x);
println!("x = {}, y = {}", x, y);
}
O x variável é o Rc variável de ponteiro, e o y variável é um clone com acesso ao valor na memória. A contagem de referência é dois e o valor é desalocado da memória quando as variáveis estão fora do escopo.
3. O ponteiro inteligente RefCell
O RefCell o ponteiro inteligente fornece mutabilidade interior que permite que referências imutáveis e mutáveis coexistam, desde que haja uma referência mutável por determinado tempo.
O RefCell ponteiro inteligente é útil ao alterar valores pertencentes a referências mutáveis.
O Refcell A função não faz parte do prelúdio do Rust, portanto, você precisará importar a estrutura da biblioteca padrão para usar o ponteiro inteligente.
usar padrão:: célula:: RefCell;fnprincipal(){
// nova instância do ponteiro inteligente Refcell
deixar x = RefCell:: novo(5);deixar y = x.emprestar();
deixar z = x.borrow_mut();println!("s = {}", *y);
println!("z = {}", *z);
}
O Refcell ponteiro inteligente contém o valor, e o y variável é a referência imutável ao valor. O emprestar_mut A função cria uma referência mutável do valor.
O programa é seguro se houver apenas uma referência mutável por vez.
4. O ponteiro inteligente Mutex
O mutex ponteiro inteligente fornece exclusões mútuas. O mutex O ponteiro inteligente é útil para sincronizar o acesso a valores em vários segmentos em programas simultâneos.
O mutex o ponteiro inteligente fornece exclusão mútua para garantir que apenas um thread possa acessar o valor enquanto evita rastreamentos de dados.
Você precisará importar o mutex struct e crie uma nova instância com o novo função para usar mutex Ponteiro inteligente em Rust.
usar std:: sincronizar:: Mutex;fnprincipal() {
// nova instância do ponteiro mutex
deixar contador = Mutex:: novo(0);{
deixarmudo num = counter.lock().unwrap();
*num += 1;
}
println!("Resultado: {}", *counter.lock().unwrap());
}
O contador a variável é a nova mutex instância. O principal função adquire um bloqueio no mutex com o trancar método do mutex instância. O bloqueio permite a modificação segura do valor do contador antes de liberar o bloqueio e imprimir o valor.
O mutex tipo garante que apenas um thread pode acessar os recursos compartilhados (neste caso, o contador variável) e modifique seu valor de cada vez. A exclusão mútua garante que o acesso simultâneo a recursos compartilhados seja serializado para evitar rastreamentos de dados e outros problemas de simultaneidade.
O modelo de propriedade do Rust garante a segurança da memória
Ponteiros inteligentes são uma das abordagens de Rust para segurança e flexibilidade de memória. O modelo de propriedade do Rust garante que os programas usem a memória com segurança com o verificador de empréstimo em tempo de compilação.
O verificador de empréstimo é um recurso crucial do modelo de propriedade do Rust que impõe regras estritas para acessibilidade e modificação de memória.
