As linguagens de programação diferem na forma como lidam com a memória e impõem as regras de gerenciamento de memória. Go e Python empregam coletores de lixo, para que os desenvolvedores possam se concentrar em escrever código. C e C++ dão aos programadores a responsabilidade de gerenciar a memória em um nível inferior.
Rust trata o gerenciamento de memória de maneira diferente, usando conceitos que chama de propriedade e empréstimo. Ele usa um "verificador de empréstimo" para reforçar a segurança da memória com eficiência.
O que é propriedade?
A propriedade é um recurso e convenção do Rust que ajuda a garantir a segurança da memória de programas sem um coletor de lixo. É outra forma de abordar o problema de vazamentos de memória em seu código.
O compilador Rust verifica se um programa obedece às regras de propriedade em tempo de compilação. Se o programa seguir essas regras, ele poderá ser executado. Se isso não acontecer, o compilador se recusa a produzir um executável.
Rust verifica as regras de propriedade usando o
cheque emprestado. O verificador de empréstimo verifica o modelo de propriedade e decide se um valor na memória (pilha ou pilha) está fora do escopo ou não. Se um valor estiver fora de seu escopo, não será acessível a outras partes do programa, a menos que seja emprestado.As regras de propriedade
No Rust, cada variável possui o valor com o qual foi inicializada e só pode haver um proprietário. Quando o proprietário estiver fora do escopo, o valor será descartado. É importante entender os detalhes das regras de propriedade.
A primeira regra de propriedade é que cada variável possui seu valor inicializado.
deixar proprietário = Corda::de um");
o proprietário a variável acima possui a string 1 e, ao contrário de linguagens como Python e Go, esse valor será descartado na reatribuição de variável.
A segunda regra de propriedade é que duas variáveis não podem apontar para o mesmo local de memória; cada valor pode ter apenas um proprietário.
deixar novo_proprietário = proprietário;
o novo dono variável agora possui o valor armazenado no local de memória do proprietário variável. Se você tentar usar o proprietário variável, o compilador entrará em pânico e se recusará a gerar um executável.
Na maioria das linguagens que usam coletores de lixo, duas variáveis podem apontar para o mesmo local de memória. Aqui está um exemplo de código JavaScript equivalente:
deixar dono = "dono";
deixar novo_proprietário = proprietário;
console.log (novo_proprietário);
A execução do código JavaScript acima funciona sem erros e, se você fizer o mesmo em Go ou Python, seu programa funcionará sem erros também.
A terceira regra de propriedade é que quando uma variável está fora do escopo declarado, o valor é descartado e a memória é desalocada.
// uma variável em um escopo separado
{
deixar exemplo = Corda::from("Aqui está um novo escopo");
}
imprimir!("{}", exemplo)
Você não pode acessar o exemplo variável fora de seu escopo; tentar fazer isso fará com que o compilador entre em pânico.
Propriedade em Funções
Quando você passa um valor para uma função como argumento, a função pode acessar essa variável mesmo que ela não tenha sido declarada em seu escopo:
fnimpressora(valor: Corda) -> Corda {
Retorna valor
}fna Principal() {
deixar x = Corda::from("Imprime um valor"); // x possui o valor da string
// a propriedade é movida para a função de impressora aqui
imprimir!("{} O Resultado de Imprimir X é que -:", impressora (x));
}
A função pode acessar essa variável porque Rust move a propriedade dela para a função em tempo de compilação.
Você pode pensar que ainda é possível usar a variável posteriormente em seu escopo original:
fnimpressora(valor: Corda) -> Corda {
Retorna valor
}fna Principal() {
deixar x = Corda::from("Imprime um valor");
imprimir!("{} O Resultado de Imprimir x é que ele -:", impressora (x));
// Tentando usar a variável depois que a propriedade de seu valor foi transferida
println!("{} não deve ser acessível", x)
}
Mas se você tentar isso, o compilador entrará em pânico e se recusará a produzir um executável:
Rust prioriza a reutilização de código
A reutilização de código é uma prática essencial, mas para praticar a reutilização de código você precisa entender as regras de propriedade da Rust.
Rust é uma linguagem de programação muito flexível. Ele fornece conceitos como empréstimo, movimentação, cópia e clonagem de propriedade para reutilização variável.
