Prestito e riferimento alla ruggine

Ogni valore in una ruggine ha una variabile che è nota come proprietario. La regola della proprietà singola Rust afferma che può esserci un solo proprietario alla volta.

Tuttavia, potremmo incontrare istanze in cui dobbiamo utilizzare e modificare temporaneamente un valore. Possiamo farlo usando il prestito. Il prestito è un concetto che ci consente di prendere in prestito un valore, usarlo e una volta terminato, restituirlo al suo proprietario nello stesso stato era quando l'abbiamo preso in prestito. Ciò significa che il prestito non modifica il valore originale.

Prendiamo in prestito un valore facendolo riferimento utilizzando il suo indirizzo di memoria e l'operatore. Possiamo quindi passare il riferimento a una funzione e utilizzare il valore come ci vediamo.

Regole di riferimento

Esistono due regole per lavorare con i riferimenti in ruggine:

1. Puoi avere riferimenti mutabili o molti riferimenti immutabili alla volta.
2. Tutti i riferimenti devono essere validi.

Riferimento di ruggine e valore prendi in prestito

In Rust, utilizziamo l'operatore e per fare riferimento a un indirizzo di valore. Un codice di esempio è come mostrato di seguito:

fn main ()
let string = string :: da ("ciao");
let str_len = get_str_length (& string);
println!("Lunghezza stringa: ", str_len);

fn get_str_length (string: & string) -> usize
Stringa di ritorno.len ();

Nel codice sopra, definiamo una variabile chiamata "String". Secondo le regole di proprietà, questa variabile possiede il valore "ciao".

Tuttavia, dobbiamo utilizzare questa variabile nella funzione. Poiché un valore può avere un proprietario solo in un determinato momento, l'utilizzo all'interno della funzione trasferirà la proprietà. Dal momento che non vogliamo trasferire la proprietà alla funzione, prendiamo in prestito il valore utilizzando facendo riferimento al suo proprietario.

Si noti che aggiungiamo l'operatore e nel tipo di parametro funzione. Questo dice a Rust che stiamo facendo riferimento al valore e dovremmo restituirlo dopo il completamento.

Riferimenti mutabili

Se tentiamo di modificare un valore preso in prestito, la ruggine comporterà un errore. Prendi l'esempio di seguito:

fn main ()
let string = string :: da ("ciao");
Change_Value (& String);

fn Change_Value (String: & String)
corda.push_str ("mondo!")

L'esecuzione del codice sopra dovrebbe restituire un errore come:

Questo perché i riferimenti sono immutabili per impostazione predefinita. Quindi, potremmo non modificare un valore preso in prestito.

Possiamo avere un riferimento mutabile che ci consente di modificare un valore preso in prestito. Considera il codice di esempio seguente:

fn main ()
let mut string = string :: da ("ciao");
Change_Value (& mut String);

fn Change_Value (String: & Mut String)
corda.push_str ("mondo!")

Nell'esempio sopra, impostiamo la variabile "stringa" t essere mutabile. Creiamo quindi un riferimento mutabile usando la stringa MUT nella chiamata di funzione. Si noti che il parametro della funzione accetta un riferimento mutabile, consentendo alla funzione di modificare il valore preso in prestito.

Nota: come accennato, puoi avere un solo riferimento mutabile in un determinato momento. Il tentativo di creare più di un riferimento mutabile lancerà un errore come mostrato:

fn main ()
let mut string = string :: da ("ciao");
let string2 = & mut string;
let string3 = & mut string;
println!(" ", string2, string3);

fn Change_Value (String: & Mut String)
corda.push_str ("mondo!")

Il codice sopra dovrebbe restituire un errore come mostrato:

Questa funzione può aiutare a prevenire le condizioni di gara quando si prendono in prestito e si riferiscono valori.

Conclusione

Questo articolo fornisce una comprensione di base dell'utilizzo e del lavoro con le funzioni di prestito e riferimento della ruggine. Puoi controllare i documenti per esplorare ulteriormente.