Wie man mit Besitz in Rost arbeitet

In diesem Artikel werden wir Rust Besitz und wie es funktioniert. Der Ansatz des Eigentums und des Kreditaufnahme ist ein relativ neues Konstrukt und Reisen Neuneuerungen. In diesem Leitfaden werden wir versuchen, zu entmystifizieren, wie das Eigentum funktioniert.

Was ist Besitz?

Traditionell gibt es zwei grundlegende Möglichkeiten, Erinnerungen zu verwalten. Der erste ist Müllsammler; Es wird hauptsächlich in hochrangigen Sprachen verwendet, die das Konzept der Gedächtnisverwaltung vom Programmierer abstrahieren.

Die zweite ist die „manuelle“ Speicherverwaltung, bei der der Programmierer ausdrücklich die Speicherverwendung definiert. Obwohl es die Kontrolle bietet, lässt es viel Platz, um sich in den Fuß zu schießen.

Rust nimmt einen alternativen Ansatz an, der als Eigentum und Kreditaufnahme bezeichnet wird. Eigentum ist ein neues „Konstrukt“, das einen Wert definiert, der seinen Eigentümer hat.

Das Folgende sind die Rostregeln:

1. Jeder in einem Rostprogramm definierte Wert hat einen Eigentümer.
2. Ein Wert kann jeweils einen Besitzer haben.
3. Ein Wert kann nur so lange leben, wie sein Besitzer lebt. Das heißt, der Besitzer wurde nicht fallen gelassen.

Lassen Sie uns einige Konzepte und Beispiele diskutieren, um Rust -Besitz besser zu verstehen.

Umfang

Wir können den Umfang als Bereich definieren, in dem ein bestimmter Wert lebt. Das Zielfernrohr spielt eine wichtige Rolle in Bezug auf Eigentum und Kreditaufnahme.

Jede Variable ist an ihren Umfang gebunden. In diesem Fall bezieht sich ein Bereich auf einen Block, der durch ein Paar lockiger Zahnspangen eingeschlossen ist.

Betrachten Sie das folgende Beispielprogramm:

fn main ()
// im Umfang der Hauptfunktion definiert
long_life = 100;

// in einem inneren Block definiert (neuer Umfang)
lass Short_life = 10;
println!("Inner Scope: ", Short_Life);

// Short_Life existiert in diesem Bereich nicht
println!("Äußerer Bereiche: ", Short_Life);
println!("Langes Leben: ", long_life);

fn new_func ()
println!("Funktionsbereich: ", long_life);

Im vorherigen Beispielprogramm haben wir zwei Funktionen: die Hauptfunktion und die Funktion new_func.

In der Hauptfunktion deklarieren wir eine neue Variable namens long_life. Wir erstellen auch einen neuen Bereich und deklarieren eine neue Variable namens Short_Life.

Wenn Sie den vorherigen Code ausführen, sagt der Rost -Compiler Ihnen, dass die Variablen, Short_Life und Long_Life, in diesem Bereich nicht existieren.

Dies liegt daran, dass die Variable Short_Life in einem neuen Bereich deklariert wird. Wenn dieses Zielfernrohr endet, wird die Variable fallen gelassen. Dies bedeutet, dass das Variable Short_Life außerhalb der lockigen Klammern nicht existiert.

Der gleiche Fall gilt für die Variable long_life. Es ist nur in der Hauptfunktion zugänglich. Der Versuch, in einer anderen Funktion darauf zuzugreifen, ist nicht zulässig.

Beschattet

Variable Schatten ist ein typischer Fall. Es bezieht sich auf eine Funktion, bei der die erste variable Erklärung „überschrieben“ oder von einem anderen beschattet wird.

Nehmen Sie den folgenden Beispielcode:

fn main ()
sei var1 = 10;
println!("Vor Schatten: ", var1);
// nach Schatten
sei var1 = 100;
println!("After Shadow: ", var1);

Hier haben wir eine Variable namens var1 auf 10 eingestellt. Dann beschatten wir sie, indem wir die Variable mit demselben Namen deklarieren und auf einen neuen Wert setzen.

Dies sollte drucken:

Hinweis: Verwechseln Sie das Schatten nicht mit Veränderlichkeit. Überprüfen Sie unser Tutorial über Rust Mutability, um mehr zu erfahren.

Eigentum übertragen

Rust ermöglicht es uns, den Wert des Wertes mithilfe von Kopier- oder Umzugsvorgängen zu übertragen. Nehmen Sie den folgenden Beispielcode:

fn main ()
sei var1 = 10;
sei var2 = var1;
println!("var1: ", var1);
println!("var2: ", var2);

Das vorherige Beispiel deklariert eine Variable, var1 und weist ihm den Wert 10 zu. Wir deklarieren auch eine neue Variable, var2, und weisen sie VAR1 zu.

In diesem Fall erstellt Rust eine neue Kopie des Wertes und ordnet ihn VAR2 zu. Dies bedeutet, dass beide Variablen den Wert nicht teilen und jeder seinen eigenen Speicherraum nimmt.

Was passiert, wenn wir versuchen, die vorherige Operation mit einer nicht deterministischen Speichergröße mit einem Wert auszuführen?

Nehmen Sie zum Beispiel einen String -Typ. Da es wachsen oder schrumpfen kann, gibt es keine vorbestimmte Speichergröße. Daher implementiert es nicht das Kopiermerkmal:

Sei str1 = String :: von ("hi");
Sei str2 = str1;
println!("Str1: ", str1);
println!("Str1: ", str2);

Das gleiche Betrieb erzwingt den Rost -Compiler, den Wert von STR1 auf Str2 zu verschieben. Da ein Wert jeweils nur einen Eigentümer haben kann, ist die variable str1 nicht mehr gültig. Dies führt dazu, dass der Compiler einen Fehler zurückgibt, wenn wir versuchen, darauf zuzugreifen:

Abschluss

Ein Grund, warum Rustaceane die Rost -Programmiersprache lieben, ist das Eigentum. Es ist eine neue Funktion, die gleichzeitig mehr Flexibilität und Sicherheit bietet. Zu verstehen, wie es funktioniert, kann für die Erstellung schneller und effizienter Anwendungen von Vorteil sein. Außerdem wurden die Regeln für Eigentum und Konzepte erörtert. Wir hoffen, Sie haben diesen Artikel hilfreich gefunden. Weitere Tipps und Informationen finden Sie in den anderen Linux -Hinweisartikeln.