Rostleisten und Referenzierung

Jeder Wert in einem Rost hat eine Variable, die als Eigentümer bezeichnet wird. Die Rost -Einzelbesitzregel besagt, dass es jeweils nur einen Eigentümer geben kann.

Wir können jedoch auf Fälle stoßen, in denen wir einen Wert vorübergehend verwenden und ändern müssen. Wir können dies mithilfe von Krediten erreichen. Das Ausleihen ist ein Konzept, das es uns ermöglicht, einen Wert auszuleihen, ihn zu benutzen. Sobald wir fertig sind, geben Sie ihn in demselben Zustand zurück, in dem wir es geliehen haben. Dies bedeutet, dass das Kreditaufbau den ursprünglichen Wert nicht ändert.

Wir leihen uns einen Wert aus, indem wir ihn anhand seiner Speicheradresse und des & Operators verweisen. Wir können dann den Verweis auf eine Funktion übergeben und den Wert verwenden, wie wir es für richtig halten.

Referenzierungsregeln

Es gibt zwei Regeln für die Arbeit mit Referenzen in Rost:

1. Sie können entweder veränderliche Referenzen oder viele unveränderliche Referenzen gleichzeitig haben.
2. Alle Referenzen müssen gültig sein.

Rostreferenz- und Ausleihenwert ausleihen

In Rost verwenden wir den & Operator, um eine Wertadresse zu verweisen. Ein Beispielcode ist wie unten gezeigt:

fn main ()
lass String = String :: von ("Hallo");
let str_len = get_str_length (& String);
println!("String Länge: ", str_len);

fn get_str_length (String: & String) -> useize
Return String.len ();

Im obigen Code definieren wir eine Variable mit dem Namen "String". Nach den Eigentumsregeln besitzt diese Variable den Wert "Hallo".

Wir müssen diese Variable jedoch in der Funktion verwenden. Da ein Wert nur zu einem bestimmten Zeitpunkt einen Eigentümer haben kann, überträgt die Verwendung des Eigentums in der Funktion das Eigentum. Da wir nicht möchten, dass der Eigentum in die Funktion übertragen wird, leihen wir den Wert mithilfe des Eigentümers aus.

Beachten Sie, dass wir den & Bediener in den Funktionsparametertyp hinzufügen. Dies zeigt Rost, dass wir auf den Wert verweisen und ihn nach Abschluss zurückgeben sollten.

Veränderliche Referenzen

Wenn wir versuchen, einen geliehenen Wert zu ändern, führt Rost zu einem Fehler. Nehmen Sie das folgende Beispiel:

fn main ()
lass String = String :: von ("Hallo");
Change_Value (& String);

fn Change_Value (String: & String)
Saite.push_str ("Welt!"))

Das Ausführen des obigen Codes sollte einen Fehler als:

Dies liegt daran, dass Referenzen standardmäßig unveränderlich sind. Daher können wir keinen geliehenen Wert ändern.

Wir können eine veränderliche Referenz haben, mit der wir einen geliehenen Wert ändern können. Betrachten Sie den folgenden Beispielcode:

fn main ()
sei mut string = string :: von ("Hallo");
Change_Value (& Mut String);

fn Change_Value (String: & Mut String)
Saite.push_str ("Welt!"))

Im obigen Beispiel setzen wir die Variable "String" t veränderlich sein. Anschließend erstellen wir eine veränderliche Referenz mit der & Mut -Zeichenfolge im Funktionsaufruf. Beachten Sie, dass der Funktionsparameter eine veränderliche Referenz akzeptiert, sodass die Funktion den geliehenen Wert ändern kann.

Hinweis: Wie bereits erwähnt, können Sie zu einem bestimmten Zeitpunkt nur eine veränderliche Referenz haben. Der Versuch, mehr als eine veränderliche Referenz zu erstellen, wirft einen Fehler wie gezeigt aus:

fn main ()
sei mut string = string :: von ("Hallo");
Sei String2 = & Mut String;
Sei String3 = & Mut String;
println!(" ", String2, String3);

fn Change_Value (String: & Mut String)
Saite.push_str ("Welt!"))

Der obige Code sollte einen Fehler wie gezeigt zurückgeben:

Diese Funktion kann dazu beitragen, Rennbedingungen beim Ausleihen und Verweisen von Werten zu verhindern.

Abschluss

Dieser Artikel bietet ein grundlegendes Verständnis für die Verwendung und Arbeiten mit Rost -Kredit- und Referenzierungsfunktionen. Sie können die Dokumente überprüfen, um weiter zu erkunden.