Ruggine - Prendere in prestito

È molto scomodo passare la proprietà di una variabile a un'altra funzione e quindi restituire la proprietà. Rust supporta un concetto, il prestito, in cui la proprietà di un valore viene trasferita temporaneamente a un'entità e quindi restituita all'entità proprietaria originale.

Considera quanto segue:

fn main(){
   // a list of nos
   let v = vec![10,20,30];
   print_vector(v);
   println!("{}",v[0]); // this line gives error
}
fn print_vector(x:Vec<i32>){
   println!("Inside print_vector function {:?}",x);
}

La funzione principale invoca una funzione print_vector () . Un vettore viene passato come parametro a questa funzione. La proprietà del vettore viene anche passata alla funzione print_vector () da main () . Il codice precedente genererà un errore come mostrato di seguito quando la funzione main () tenta di accedere al vettore v .

|  print_vector(v);
|     - value moved here
|  println!("{}",v[0]);
|     ^ value used here after move

Questo perché una variabile o un valore non può più essere utilizzato dalla funzione che lo possedeva originariamente una volta che la proprietà è stata trasferita a un'altra funzione.

Cos'è il prestito?

Quando una funzione trasferisce temporaneamente il suo controllo su una variabile / valore a un'altra funzione, per un po ', si parla di prestito. Ciò si ottiene passando un riferimento alla variabile(& var_name)piuttosto che passare la variabile / valore stesso alla funzione. La proprietà della variabile / valore viene trasferita al proprietario originale della variabile dopo che la funzione alla quale è stato passato il controllo completa l'esecuzione.

fn main(){
   // a list of nos
   let v = vec![10,20,30];
   print_vector(&v); // passing reference
   println!("Printing the value from main() v[0]={}",v[0]);
}
fn print_vector(x:&Vec<i32>){
   println!("Inside print_vector function {:?}",x);
}

Produzione

Inside print_vector function [10, 20, 30]
Printing the value from main() v[0] = 10

Riferimenti mutevoli

Una funzione può modificare una risorsa presa in prestito utilizzando un riferimento mutevole a tale risorsa. Un riferimento modificabile è preceduto da&mut. I riferimenti mutabili possono operare solo su variabili mutabili.

Illustrazione: mutamento di un riferimento intero

fn add_one(e: &mut i32) {
   *e+= 1;
}
fn main() {
   let mut i = 3;
   add_one(&mut i);
   println!("{}", i);
}

La funzione main () dichiara una variabile intera mutabile i e passa un riferimento mutabile di i al fileadd_one(). Add_one () incrementa il valore della variabile i di uno.

Illustrazione: modifica di un riferimento di stringa

fn main() {
   let mut name:String = String::from("TutorialsPoint");
   display(&mut name); 
   //pass a mutable reference of name
   println!("The value of name after modification is:{}",name);
}
fn display(param_name:&mut String){
   println!("param_name value is :{}",param_name);
   param_name.push_str(" Rocks"); 
   //Modify the actual string,name
}

La funzione main () passa un riferimento mutabile del nome della variabile alla funzione display () . La funzione di visualizzazione aggiunge una stringa aggiuntiva alla variabile del nome originale .

Produzione

param_name value is :TutorialsPoint
The value of name after modification is:TutorialsPoint Rocks