Rost - Eigentum

Der Speicher für ein Programm kann wie folgt zugewiesen werden:

Stack
Heap

Stapel

Ein Stapel folgt einem letzten in der ersten Reihenfolge. Der Stapel speichert Datenwerte, deren Größe zur Kompilierungszeit bekannt ist. Beispielsweise ist eine Variable mit fester Größe i32 ein Kandidat für die Stapelzuweisung. Seine Größe ist zur Kompilierungszeit bekannt. Alle Skalartypen können im Stapel gespeichert werden, wenn die Größe festgelegt ist.

Betrachten Sie ein Beispiel für eine Zeichenfolge, der zur Laufzeit ein Wert zugewiesen wird. Die genaue Größe einer solchen Zeichenfolge kann zur Kompilierungszeit nicht ermittelt werden. Es ist also kein Kandidat für die Stapelzuweisung, sondern für die Heapzuweisung.

Haufen

Der Heapspeicher speichert Datenwerte, deren Größe zur Kompilierungszeit unbekannt ist. Es wird zum Speichern dynamischer Daten verwendet. Einfach ausgedrückt wird ein Heapspeicher Datenwerten zugewiesen, die sich während des gesamten Lebenszyklus des Programms ändern können. Der Heap ist ein Bereich im Speicher, der im Vergleich zum Stapel weniger organisiert ist.

Was ist Eigentum?

Jeder Wert in Rust hat eine Variable, die aufgerufen wird ownerdes Wertes. Allen in Rust gespeicherten Daten ist ein Eigentümer zugeordnet. In der Syntax - let age = 30 - ist age beispielsweise der Eigentümer des Werts 30 .

Jede Daten kann jeweils nur einen Eigentümer haben.
Zwei Variablen können nicht auf denselben Speicherort verweisen. Die Variablen zeigen immer auf verschiedene Speicherorte.

Eigentumsübertragung

Das Eigentum an Wert kann übertragen werden durch -

Zuweisen des Werts einer Variablen zu einer anderen Variablen.
Wert an eine Funktion übergeben.
Rückgabewert einer Funktion.

Zuweisen des Werts einer Variablen zu einer anderen Variablen

Das Hauptverkaufsargument von Rust als Sprache ist die Gedächtnissicherheit. Die Speichersicherheit wird durch eine strenge Kontrolle darüber erreicht, wer was und wann Einschränkungen verwenden kann.

Betrachten Sie das folgende Snippet -

fn main(){
   let v = vec![1,2,3]; 
   // vector v owns the object in heap

   //only a single variable owns the heap memory at any given time
   let v2 = v; 
   // here two variables owns heap value,
   //two pointers to the same content is not allowed in rust

   //Rust is very smart in terms of memory access ,so it detects a race condition
   //as two variables point to same heap

   println!("{:?}",v);
}

Das obige Beispiel deklariert einen Vektor v. Die Idee des Eigentums ist, dass auch nur eine Variable an eine Ressource gebunden ist v bindet an Ressource oder v2bindet an die Ressource. Das obige Beispiel löst einen Fehler aus - Verwendung des verschobenen Werts: `v` . Dies liegt daran, dass das Eigentum an der Ressource auf Version 2 übertragen wird. Dies bedeutet, dass das Eigentum von v nach v2 verschoben wird (v2 = v) und v nach dem Verschieben ungültig wird.

Wert an eine Funktion übergeben

Der Besitz eines Werts ändert sich auch, wenn wir ein Objekt im Heap an einen Abschluss oder eine Funktion übergeben.

fn main(){
   let v = vec![1,2,3];     // vector v owns the object in heap
   let v2 = v;              // moves ownership to v2
   display(v2);             // v2 is moved to display and v2 is invalidated
   println!("In main {:?}",v2);    //v2 is No longer usable here
}
fn display(v:Vec<i32>){
   println!("inside display {:?}",v);
}

Rückgabewert einer Funktion

Das an die Funktion übergebene Eigentum wird ungültig, wenn die Funktionsausführung abgeschlossen ist. Eine Lösung hierfür besteht darin, dass die Funktion das eigene Objekt an den Aufrufer zurückgibt.

fn main(){
   let v = vec![1,2,3];       // vector v owns the object in heap
   let v2 = v;                // moves ownership to v2
   let v2_return = display(v2);    
   println!("In main {:?}",v2_return);
}
fn display(v:Vec<i32>)->Vec<i32> { 
   // returning same vector
   println!("inside display {:?}",v);
}

Eigentum und primitive Typen

Bei primitiven Typen wird der Inhalt einer Variablen in eine andere kopiert. Es findet also kein Eigentümerwechsel statt. Dies liegt daran, dass eine primitive Variable weniger Ressourcen benötigt als ein Objekt. Betrachten Sie das folgende Beispiel -

fn main(){
   let u1 = 10;
   let u2 = u1;  // u1 value copied(not moved) to u2

   println!("u1 = {}",u1);
}

Die Ausgabe wird - 10 sein.