Como trabalhar com a propriedade da ferrugem

Neste artigo, exploraremos a propriedade da ferrugem e como funciona. A abordagem de propriedade e empréstimos é uma construção relativamente nova e viagens para os novos. Neste guia, tentaremos desmistificar como a propriedade funciona.

O que é propriedade?

Tradicionalmente, existem duas maneiras fundamentais de gerenciar memórias. O primeiro é os colecionadores de lixo; É usado principalmente em idiomas de alto nível que abstraem o conceito de gerenciamento de memória do programador.

O segundo é o gerenciamento de memória "manual", onde o programador define explicitamente o uso da memória. Embora forneça controle, deixa muito espaço para atirar no pé.

A ferrugem assume uma abordagem alternativa chamada propriedade e empréstimos. A propriedade é um novo "construto" que define um valor tem seu proprietário.

A seguir, são apresentadas as regras de propriedade da ferrugem:

1. Qualquer valor definido em um programa de ferrugem tem um proprietário.
2. Um valor pode ter um proprietário de cada vez.
3. Um valor só pode viver enquanto seu dono estiver vivo. O que significa que o proprietário não foi descartado.

Para entender melhor a propriedade da ferrugem, discutimos alguns conceitos e exemplos.

Escopo

Podemos definir o escopo como um intervalo sob o qual um valor especificado vive. O escopo desempenha um papel importante em propriedade e empréstimos.

Cada variável está vinculada por seu escopo. Nesse caso, um escopo refere -se a um bloco, fechado por um par de aparelhos encaracolados.

Considere o seguinte programa de exemplo:

fn main ()
// definido no escopo da função principal
deixe long_life = 100;

// definido em um bloco interno (novo escopo)
deixe Short_life = 10;
println!("Escopo interno: ", Short_life);

// short_life não existe neste escopo
println!("Escopo externo: ", Short_life);
println!("Long Life: ", long_life);

fn new_func ()
println!("Scope da função: ", long_life);

No programa de exemplo anterior, temos duas funções: a função principal e a função new_func.

Dentro da função principal, declaramos uma nova variável chamada Long_life. Também criamos um novo escopo e declaramos uma nova variável chamada Short_life.

Se você executar o código anterior, o compilador de ferrugem lhe dirá que as variáveis, Short_life e Long_life, não existem nesse escopo.

Isso ocorre porque a variável Short_life é declarada em um novo escopo. Quando esse escopo termina, a variável é descartada. Isso significa que a variável Short_life não existe fora do aparelho encaracolado.

O mesmo caso se aplica à variável long_life. É acessível apenas na função principal. Tentar acessá -lo em outra função não é permitido.

Shadowing

Shadowing variável é um caso típico. Refere -se a um recurso em que a primeira declaração variável é "substituída" ou sombreada por outro.

Pegue o seguinte código de exemplo:

fn main ()
Seja var1 = 10;
println!("Antes da sombra: ", var1);
// depois da sombra
Seja var1 = 100;
println!("After Shadow: ", var1);

Aqui, temos uma variável chamada var1 definida para 10. Em seguida, sombreamos declarando a variável com o mesmo nome e definimos para um novo valor.

Isso deve imprimir:

Nota: Não confunda sombreamento com mutabilidade. Verifique nosso tutorial sobre a mutabilidade da ferrugem para aprender mais.

Transferir propriedade

Rust nos permite transferir a propriedade do valor usando operações de cópia ou movimentação. Pegue o seguinte código de exemplo:

fn main ()
Seja var1 = 10;
Seja var2 = var1;
println!("var1: ", var1);
println!("var2: ", var2);

O exemplo anterior declara uma variável, var1 e atribui o valor 10. Também declaramos uma nova variável, var2, e atribuímos a Var1.

Quando isso acontecer, a ferrugem criará uma nova cópia do valor e a atribui a var2. Isso significa que ambas as variáveis ​​não compartilham o valor e cada uma ocupa seu próprio espaço de memória.

O que acontece quando tentamos realizar a operação anterior em um valor com um tamanho de memória não determinístico?

Veja um tipo de string, por exemplo. Como pode crescer ou encolher, não há tamanho de memória pré-determinado. Portanto, não implementa o traço de cópia:

Seja str1 = string :: de ("oi");
Seja STR2 = STR1;
println!("str1: ", str1);
println!("str1: ", str2);

Executar a mesma operação força o compilador de ferrugem a mover o valor de str1 para str2. Como um valor pode ter apenas um proprietário de cada vez, a variável str1 não é mais válida. Isso fará com que o compilador retorne um erro se tentarmos acessá -lo:

Conclusão

Uma das razões pelas quais Rustaceans adora a linguagem de programação de ferrugem é a propriedade. É um novo recurso que oferece mais flexibilidade e segurança ao mesmo tempo. Compreender como funciona pode ser benéfico para criar aplicativos rápidos e eficientes. Além disso, as regras de propriedade e conceitos foram discutidos. Esperamos que você tenha achado este artigo útil. Verifique os outros artigos de dica do Linux para obter mais dicas e informações.