Rost - Ausleihen

Es ist sehr unpraktisch, den Besitz einer Variablen an eine andere Funktion zu übergeben und dann den Besitz zurückzugeben. Rust unterstützt ein Konzept der Kreditaufnahme, bei dem das Eigentum an einem Wert vorübergehend auf ein Unternehmen übertragen und dann an das ursprüngliche Eigentümerunternehmen zurückgegeben wird.

Betrachten Sie Folgendes:

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);
}

Die Hauptfunktion ruft eine Funktion print_vector () auf . Ein Vektor wird als Parameter an diese Funktion übergeben. Der Besitz des Vektors wird auch von main () an die Funktion print_vector () übergeben . Der obige Code führt zu einem Fehler wie unten gezeigt, wenn die Funktion main () versucht, auf den Vektor v zuzugreifen .

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

Dies liegt daran, dass eine Variable oder ein Wert von der Funktion, der sie ursprünglich gehörte, nicht mehr verwendet werden kann, sobald der Besitz auf eine andere Funktion übertragen wurde.

Was ist Ausleihen?

Wenn eine Funktion für eine Weile vorübergehend die Kontrolle über eine Variable / einen Wert auf eine andere Funktion überträgt, spricht man von Ausleihen. Dies wird erreicht, indem ein Verweis auf die Variable übergeben wird(& var_name)anstatt die Variable / den Wert selbst an die Funktion zu übergeben. Der Besitz der Variablen / des Werts wird auf den ursprünglichen Besitzer der Variablen übertragen, nachdem die Funktion, an die das Steuerelement übergeben wurde, die Ausführung abgeschlossen hat.

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);
}

Ausgabe

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

Veränderbare Referenzen

Eine Funktion kann eine ausgeliehene Ressource mithilfe eines veränderlichen Verweises auf eine solche Ressource ändern . Einer veränderlichen Referenz wird ein Präfix vorangestellt&mut. Veränderbare Referenzen können nur mit veränderlichen Variablen arbeiten.

Abbildung: Mutieren einer Ganzzahlreferenz

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

Die Funktion main () deklariert eine veränderbare Ganzzahlvariable i und übergibt eine veränderbare Referenz von i an dieadd_one(). Das add_one () erhöht den Wert der Variablen i um eins.

Abbildung: Mutieren einer Zeichenfolgenreferenz

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
}

Die main () Funktion gibt eine veränderliche Referenz des variablen Namen mit dem Display () Funktion. Die Anzeigefunktion fügt eine zusätzliche Zeichenfolge an den ursprünglichen Namen Variable.

Ausgabe

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