Empréstimo de ferrugem e referência

Cada valor em uma ferrugem tem uma variável conhecida como seu proprietário. A regra de propriedade única da ferrugem afirma que pode haver apenas um proprietário de cada vez.

No entanto, podemos encontrar instâncias em que precisamos usar e modificar um valor temporariamente. Podemos conseguir isso usando empréstimos. Empréstimo é um conceito que nos permite emprestar um valor, usá -lo e, assim que terminarmos, devolva -o ao seu proprietário no mesmo estado que foi quando o pegamos emprestado. Isso significa que o empréstimo não altera o valor original.

Emprestamos um valor referenciando -o usando seu endereço de memória e o operador. Podemos então passar a referência a uma função e usar o valor como consideramos adequado.

Regras de referência

Existem duas regras para trabalhar com referências em ferrugem:

1. Você pode ter referências mutáveis ​​ou muitas referências imutáveis.
2. Todas as referências devem ser válidas.

Referência de ferrugem e valor emprestado

Na ferrugem, usamos o Operador para fazer referência a um endereço de valor. Um código de exemplo é como mostrado abaixo:

fn main ()
Deixe String = String :: de ("Hello");
Seja str_len = get_str_length (& string);
println!("Comprimento da string: ", str_len);

fn get_str_length (string: & string) -> usize
Retornar string.Len ();

No código acima, definimos uma variável chamada "string". De acordo com as regras de propriedade, essa variável possui o valor "Olá".

No entanto, precisamos usar essa variável na função. Como um valor só pode ter um proprietário em um determinado momento, usá -lo dentro da função transferirá a propriedade. Como não queremos que a propriedade seja transferida para a função, emprestamos o valor usando referenciando seu proprietário.

Observe que adicionamos o Operador no tipo de parâmetro de função. Isso diz a Rust que estamos referenciando o valor e deve devolvê -lo após a conclusão.

Referências mutáveis

Se tentarmos mudar um valor emprestado, a ferrugem resultará em um erro. Veja o exemplo abaixo:

fn main ()
Deixe String = String :: de ("Hello");
change_value (& string);

fn change_value (string: & string)
corda.push_str ("mundo!")

A execução do código acima deve retornar um erro como:

Isso ocorre porque as referências são imutáveis ​​por padrão. Portanto, não podemos modificar um valor emprestado.

Podemos ter uma referência mutável que nos permite modificar um valor emprestado. Considere o código de exemplo abaixo:

fn main ()
Deixe mut string = string :: de ("hello");
change_value (& mut string);

fn change_value (string: & mut string)
corda.push_str ("mundo!")

No exemplo acima, definimos a variável "string" t ser mutável. Em seguida, criamos uma referência mutável usando a string & mut na chamada de função. Observe que o parâmetro de função aceita uma referência mutável, permitindo que a função altere o valor emprestado.

Nota: Como mencionado, você pode ter apenas uma referência mutável em um determinado momento. Tentar criar mais de uma referência mutável lançará um erro como mostrado:

fn main ()
Deixe mut string = string :: de ("hello");
deixe string2 = & mut string;
deixe string3 = & mut string;
println!(" ", string2, string3);

fn change_value (string: & mut string)
corda.push_str ("mundo!")

O código acima deve retornar um erro como mostrado:

Esse recurso pode ajudar a prevenir as condições de raça ao emprestar e referenciar valores.

Conclusão

Este artigo fornece uma compreensão básica de usar e trabalhar com os recursos de empréstimos e referenciações de ferrugem. Você pode verificar os documentos para explorar mais.