Rust usa um verificador de empréstimo para impor suas regras de propriedade e garantir que os programas sejam seguros para a memória. As regras de propriedade ditam como o Rust gerencia a memória na pilha e no heap.
Ao escrever programas Rust, você precisará usar variáveis sem alterar a propriedade do valor associado. Rust fornece um mecanismo de empréstimo robusto para incentivar a flexibilidade e a reutilização de código.
O que é empréstimo em Rust?
Empréstimo é acessar o valor de uma variável sem assumindo a propriedade da variável referenciando o proprietário. O verificador de empréstimo garante que a referência seja válida e que os dados não sejam descartados usando uma construção chamada vidas.
Um tempo de vida é quanto tempo uma variável existe. A vida útil começa na criação da variável e termina na destruição da variável. Você pode emprestar a propriedade de uma variável e, quando a referência emprestada estiver fora do escopo, a propriedade retornará à variável proprietária. O empréstimo é um pouco como o
ponteiros que você encontrará em linguagens como C++ e Go. Mas o compilador Rust usa o verificador de empréstimos para garantir que os programas sejam seguros para a memória.Um exemplo de empréstimo em ferrugem
Você pode emprestar a propriedade de uma variável fazendo referência ao proprietário usando o símbolo e comercial (&).
fna Principal() {
deixar x = Corda::from("Olá"); // x possui "olá"
deixar y = &x; // y referencia x, empresta "hello"
println!("{}", x);
println!("{}", s)
}
Sem empréstimos por referência, o programa entraria em pânico. Isso violaria a regra de propriedade de que um valor pode ter um proprietário e duas variáveis não podem apontar para o mesmo local de memória. O empréstimo pode ser muito útil em funções. Aqui está um exemplo de empréstimo em uma função, para manter a propriedade enquanto chama outras funções que recebem variáveis locais como argumentos.
fnimprimir_mesmo(vetor: &Vec<i32>) {
por valores dentro vetor {
E se valores % 2 == 0 {
println!("{}", valores);
}
}
}
o imprimir_mesmo A função referencia um vetor de inteiros de 32 bits como seu argumento. Em seguida, ele imprime linhas de valores que são múltiplos de dois no vetor usando um loop for e o println! macro.
fna Principal() {
deixar número_vetor = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
print_even(&number_vector); // a propriedade é emprestada, não movida
println!("A função principal retém a propriedade do vetor numérico{:?}", number_vector)
}
A função main declara a variável number_vector e atribui a ela um vetor de inteiros de 32 bits. Em seguida, ele chama a função print_even e passa uma referência para o número_vetor variável usando o símbolo e comercial.
A função principal mantém a propriedade do número_vetor variável, ele pode continuar a usar o valor em seu local de memória.
Referências de empréstimo e mutação
As funções também podem modificar variáveis emprestadas usando referências mutáveis a elas, antes de retornar a propriedade.
No entanto, ao contrário das variáveis regulares que podem ser definidas como mutáveis usando a palavra-chave mut, você deve prefixar as referências mutáveis com o símbolo e comercial.
Antes de fazer referências mutáveis, a variável que você deseja modificar deve ser mutável.
fnremove_value(vetor: &mudoVec<i32>) -> &Vec<i32> {
vectr.remove(4);
Retorna vetor
}
o remove_value A função recebe a referência de um vetor mutável de inteiros de 32 bits. Ele retorna um vetor de inteiros de 32 bits após remover o valor do vetor no quarto índice.
fna Principal() {
deixarmudo números = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
remove_value(&mudo números); // referência mutável aqui
println!("{:?}", números);
}
A função modifica o números vector chamando remove_value e passando a referência mutável de um vetor como um argumento. Ao imprimir o vetor, o quarto índice anterior do vetor não existe.
Observe que o argumento é uma referência a um vetor mutável.
É importante entender a propriedade e o empréstimo
Você precisará entender a propriedade e o empréstimo para escrever um código Rust eficiente e seguro para a memória que compila e executa. Se o seu código não seguir as regras de propriedade, o verificador de empréstimos o detectará. Você precisará tornar seu programa seguro para a memória para que o Rust o compile.
O verificador de empréstimos é irritante quando você é novo no Rust. Mas, à medida que você escreve mais código Rust, você se acostuma e ganha experiência em escrever código Rust com memória segura.