Rust utilizza un controllore di prestito per far rispettare le sue regole di proprietà e garantire che i programmi siano protetti dalla memoria. Le regole di proprietà determinano il modo in cui Rust gestisce la memoria nello stack e nell'heap.
Mentre scrivi i programmi Rust, dovrai utilizzare le variabili senza modificare la proprietà del valore associato. Rust fornisce un solido meccanismo di prestito per incoraggiare la flessibilità e il riutilizzo del codice.
Che cosa è prendere in prestito in Rust?
Prendere in prestito è accedere al valore di una variabile senza assumere la proprietà della variabile facendo riferimento al proprietario. Il controllo del prestito assicura che il riferimento sia valido e che i dati non vengano eliminati utilizzando un costrutto chiamato durate.
Una vita è quanto tempo esiste una variabile. Le vite iniziano con la creazione di variabili e terminano con la distruzione delle variabili. È possibile prendere in prestito la proprietà di una variabile e, quando il riferimento preso in prestito non rientra nell'ambito, la proprietà ritorna alla variabile del proprietario. Prendere in prestito è un po' come il
puntatori che troverai in linguaggi come C++ e Go. Ma il compilatore Rust usa il controllo di prestito per garantire che i programmi siano sicuri per la memoria.Un esempio di prestito in Rust
Puoi prendere in prestito la proprietà di una variabile facendo riferimento al proprietario utilizzando il simbolo e commerciale (&).
fnprincipale() {
permettere x = Corda::da("ciao"); // x possiede "ciao"
permettere y = &x; // y fa riferimento a x, prende in prestito "ciao"
stampa!("{}", X);
stampa!("{}", y)
}
Senza prendere in prestito facendo riferimento, il programma andrebbe nel panico. Violerebbe la regola di proprietà secondo cui un valore può avere un proprietario e due variabili non possono puntare alla stessa posizione di memoria. Il prestito può essere molto utile nelle funzioni. Ecco un esempio di prestito in una funzione, per mantenere la proprietà mentre si chiamano altre funzioni che prendono variabili locali come argomenti.
fnstampa_pari(vettoriale: &Vec<i32>) {
per i valori in vettore {
Se i valori % 2 == 0 {
stampa!("{}", i valori);
}
}
}
Il stampa_pari La funzione fa riferimento a un vettore di numeri interi a 32 bit come argomento. Quindi stampa righe di valori multipli di due nel vettore usando un ciclo for e println! macro.
fnprincipale() {
permettere numero_vettore = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
stampa_pari(&numero_vettore); // la proprietà è presa in prestito, non spostata
stampa!("La funzione principale mantiene la proprietà del vettore numero{:?}", vettore_numero)
}
La funzione principale dichiara la variabile number_vector e le assegna un vettore di numeri interi a 32 bit. Quindi chiama la funzione print_even e le passa un riferimento a numero_vettore variabile utilizzando il simbolo e commerciale.
La funzione principale mantiene la proprietà del numero_vettore variabile può continuare a utilizzare il valore nella sua posizione di memoria.
Riferimenti in prestito e mutanti
Le funzioni possono anche modificare le variabili prese in prestito usando riferimenti mutevoli ad esse, prima di restituire la proprietà.
Tuttavia, a differenza delle variabili regolari che possono essere impostate su mutabili utilizzando la parola chiave mut, è necessario anteporre i riferimenti mutabili con il simbolo e commerciale.
Prima di creare riferimenti mutabili, la variabile che si desidera modificare deve essere mutabile.
fnremove_value(vettoriale: &muVec<i32>) -> &Vec<i32> {
vectr.remove(4);
Restituzione vettore
}
Il remove_value la funzione prende il riferimento di un vettore mutabile di interi a 32 bit. Restituisce un vettore di numeri interi a 32 bit dopo aver rimosso il valore del vettore nel quarto indice.
fnprincipale() {
permetteremu numeri = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
remove_value(&mu numeri); // riferimento mutevole qui
stampa!("{:?}", numeri);
}
La funzione modifica il num vector chiamando remove_value e passando il riferimento mutevole di un vettore come argomento. Sulla stampa del vettore, il quarto indice precedente del vettore non esiste.
Si noti che l'argomento è un riferimento a un vettore mutabile.
È importante capire la proprietà e il prestito
Avrai bisogno di comprendere la proprietà e il prestito per scrivere codice Rust efficiente e sicuro per la memoria che venga compilato ed eseguito. Se il tuo codice non segue le regole di proprietà, il controllo del prestito lo rileverà. Dovrai rendere il tuo programma sicuro per la memoria affinché Rust possa compilarlo.
Il controllo dei prestiti è fastidioso quando non conosci Rust. Ma, man mano che scrivi più codice Rust, ti ci abituerai e acquisirai esperienza nella scrittura di codice Rust sicuro per la memoria.
