Rust-Ownership
Computerprogramme müssen die Speicherressourcen, die sie zur Laufzeit verwenden, verwalten.
Die meisten Programmiersprachen verfügen über Speicherverwaltungsfunktionen:
Sprachen wie C/C++ verwalten Speicher hauptsächlich manuell; Entwickler müssen Speicherressourcen manuell zuweisen und freigeben. Um die Entwicklungseffizienz zu verbessern, haben jedoch viele Entwickler nicht die Angewohnheit, Speicher rechtzeitig freizugeben, solange dies das Programm nicht beeinträchtigt. Daher führt manuelle Speicherverwaltung oft zu Ressourcenverschwendung.
In Java geschriebene Programme laufen in einer virtuellen Maschine (JVM), die die Fähigkeit besitzt, Speicherressourcen automatisch zurückzugewinnen. Dieser Ansatz verringert jedoch oft die Laufzeiteffizienz, daher gewinnt die JVM Ressourcen so wenig wie möglich zurück, was auch dazu führt, dass Programme eine größere Menge an Speicherressourcen belegen.
Eigentümerschaft ist ein neuartiges Konzept für die meisten Entwickler; sie ist ein syntaktischer Mechanismus, der von der Sprache Rust für eine effiziente Speichernutzung entworfen wurde. Das Eigentümerschaftskonzept wurde geschaffen, damit Rust den Nutzen von Speicherressourcen zur Kompilierzeit effektiver analysieren kann und dadurch Speicherverwaltung erreicht.
Eigentümerschaftsregeln
Die Eigentümerschaft hat die folgenden drei Regeln:
- Jeder Wert in Rust hat eine Variable, die als sein Eigentümer bezeichnet wird.
- Es kann zu einem Zeitpunkt nur einen Eigentümer geben.
- Wenn der Eigentümer den Gültigkeitsbereich verlässt, wird der Wert freigegeben.
Diese drei Regeln bilden die Grundlage des Eigentümerschaftskonzepts.
Als Nächstes führen wir Konzepte ein, die mit dem Eigentümerschaftskonzept zusammenhängen.
Gültigkeitsbereich von Variablen
Wir verwenden das folgende Programm, um das Konzept des Gültigkeitsbereichs einer Variablen zu beschreiben:
{
// 在声明以前,变量 s 无效
let s = "example";
// 这里是变量 s 的可用范围
}
// 变量范围已经结束,变量 s 无效Der Gültigkeitsbereich einer Variablen ist ein Attribut einer Variablen. Er repräsentiert den gültigen Bereich der Variablen; standardmäßig ist er von der Deklaration der Variablen bis zum Ende des Gültigkeitsbereichs gültig, in dem sich die Variable befindet.
Speicher und Allokation
Wenn wir eine Variable definieren und ihr einen Wert zuweisen, befindet sich der Wert der Variablen im Speicher. Das ist sehr üblich. Wenn jedoch die Länge der Daten, die wir speichern müssen, ungewiss ist (zum Beispiel eine vom Benutzer eingegebene Zeichenkette), können wir die Datenlänge zum Definitionszeitpunkt nicht bestimmen und auch nicht dafür sorgen, dass das Programm in der Kompilierungsphase einen Speicherbereich fester Länge für die Datenspeicherung reserviert. (Manche sagen, dass die Zuweisung von möglichst viel Speicherplatz das Problem lösen kann, aber diese Methode ist nicht elegant.) Dafür ist ein Mechanismus erforderlich, durch den das Programm selbst während der Laufzeit Speicher anfordert—den Heap. Alle in diesem Kapitel diskutierten "Speicherressourcen" beziehen sich auf den Speicherplatz, den der Heap belegt.
Mit der Allokation geht die Deallokation einher; ein Programm kann nicht dauerhaft eine Speicherressource belegen. Daher ist der entscheidende Faktor dafür, ob Ressourcen verschwendet werden, ob sie rechtzeitig deallokiert werden.
Schreiben wir eine äquivalente C-Version des String-Beispielprogramms:
char *s = strdup("example");
free(s); // Deallokiere die Ressource von s
}
Offensichtlich ruft Rust keine free-Funktion auf, um die Ressourcen von String s freizugeben (ich weiß, dass dies eine inkorrekte Art ist, es in C zu schreiben, weil "example" nicht auf dem Heap liegt; hier nehmen wir an, dass es so ist). Der Grund, warum Rust den Deallokationsschritt nicht explizit zeigt, ist, dass der Rust-Compiler automatisch einen Schritt hinzufügt, um die Ressourcen-Deallokationsfunktion aufzurufen, wenn der Gültigkeitsbereich der Variablen endet.
Dieser Mechanismus mag einfach erscheinen: Er hilft dem Programmierer lediglich, an der passenden Stelle einen Aufruf der Ressourcen-Deallokationsfunktion hinzuzufügen. Aber dieser einfache Mechanismus kann effektiv eines der lästigsten Programmierprobleme der Geschichte für Programmierer lösen.
Arten, wie Variablen und Daten interagieren
Es gibt zwei Hauptarten, wie Variablen und Daten interagieren: Move und Clone.
Move
Mehrere Variablen können in Rust auf unterschiedliche Weise mit denselben Daten interagieren:
let x = 5; let y = x;
Dieses Programm bindet den Wert 5 an die Variable x, kopiert dann den Wert von x und weist ihn der Variablen y zu. Nun gibt es zwei Werte 5 auf dem Stack. In diesem Fall sind die Daten vom Typ "Basisdaten", der nicht auf dem Heap gespeichert werden muss. Das "Move" für Daten, die sich nur auf dem Stack befinden, ist direktes Kopieren, was weder mehr Zeit noch mehr Speicherplatz beansprucht. Die "Basisdaten"-Typen sind:
- Alle Ganzzahltypen wie i32, u32, i64 usw.
- Der boolesche Typ bool mit den Werten true oder false.
- Alle Gleitkommatypen, f32 und f64.
- Der Zeichentyp char.
- Tupel, die nur Daten der oben genannten Typen enthalten.
Aber wenn sich die interagierenden Daten auf dem Heap befinden, ist das eine andere Situation:
let s1 = String::from("hello");
let s2 = s1;Der erste Schritt erstellt ein String-Objekt mit dem Wert "hello". Hier kann "hello" als Daten mit unbestimmter Länge betrachtet werden, die auf dem Heap gespeichert werden müssen.
Der zweite Schritt ist etwas anders (Das ist nicht ganz richtig; es dient nur dem Vergleich und als Referenz):

Wie in der Abbildung gezeigt: Die beiden String-Objekte befinden sich auf dem Stack, jedes String-Objekt hat einen Zeiger auf die Zeichenkette "hello" auf dem Heap. Bei der Zuweisung an s2 werden nur die Daten auf dem Stack kopiert; die Zeichenkette auf dem Heap bleibt die ursprüngliche Zeichenkette.
Wir haben zuvor erwähnt, dass Rust, wenn eine Variable den Gültigkeitsbereich verlässt, automatisch die Ressourcenfreigabefunktion aufruft und den Heap-Speicher der Variable bereinigt. Aber wenn sowohl s1 als auch s2 freigegeben würden, würde das "hello" im Heap-Bereich zweimal freigegeben, was das System nicht zulässt. Um Sicherheit zu gewährleisten, wird s1 bei der Zuweisung an s2 ungültig. Genau: Nachdem der Wert von s1 an s2 zugewiesen wurde, kann s1 nicht mehr verwendet werden. Das folgende Programm ist falsch:
let s1 = String::from("hello");
let s2 = s1;
println!("{}, world!", s1); // 错误!s1 已经失效
Die tatsächliche Situation ist also:

s1 existiert nur noch dem Namen nach.
Clone
Rust versucht, die Laufzeitkosten von Programmen so weit wie möglich zu reduzieren, daher werden standardmäßig größere Daten auf dem Heap gespeichert, und die Dateninteraktion verwendet die move-Methode. Wenn Sie jedoch Daten einfach kopieren möchten, um sie anderweitig zu verwenden, können Sie die zweite Art der Dateninteraktion verwenden – das Klonen.
Beispiel
let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2);
}
Ausgabe:
s1 = hello, s2 = hello
Hier wird das "hello" auf dem Heap tatsächlich kopiert, sodass s1 und s2 jeweils an einen Wert gebunden sind, und bei der Freigabe werden sie als zwei Ressourcen behandelt.
Natürlich sollte Klonen nur verwendet werden, wenn Kopieren erforderlich ist, schließlich dauert das Kopieren von Daten mehr Zeit.
Ownership-Mechanismus in Funktionen
Dies ist die komplexeste Situation für Variablen.
Wenn eine Variable als Funktionsargument an eine andere Funktion übergeben wird, wie geht man dann sicher mit Ownership um?
Das folgende Programm beschreibt, wie der Ownership-Mechanismus in dieser Situation funktioniert:
Beispiel
let s = String::from("hello");
// s ist als gültig deklariert
takes_ownership(s);
// Der Wert von s wird als Argument in die Funktion übergeben
// s kann also als verschoben betrachtet werden, und ab hier ist es nicht mehr gültig
let x = 5;
// x ist als gültig deklariert
makes_copy(x);
// Der Wert von x wird als Argument an die Funktion übergeben
// Aber x ist ein Basistyp, also bleibt es gültig
// Hier können wir x noch verwenden, aber nicht s
} // Die Funktion endet, x wird ungültig, dann s. Aber s wurde verschoben, also muss es nicht freigegeben werden
fn takes_ownership(some_string: String) {
// Ein String-Argument some_string wird übergeben, gültig
println!("{}", some_string);
} // Die Funktion endet, das Argument some_string wird hier freigegeben
fn makes_copy(some_integer: i32) {
// Ein i32-Argument some_integer wird übergeben, gültig
println!("{}", some_integer);
} // Funktion endet, Argument some_integer ist ein Basistyp, muss nicht freigegeben werden
Wenn eine Variable als Argument an eine Funktion übergeben wird, hat das denselben Effekt wie ein Move.
Ownership-Mechanismus von Funktionsrückgabewerten
Beispiel
let s1 = gives_ownership();
// gives_ownership verschiebt seinen Rückgabewert an s1
let s2 = String::from("hello");
// s2 wird als gültig deklariert
let s3 = takes_and_gives_back(s2);
// s2 wird als Argument verschoben, s3 erlangt Ownership am Rückgabewert
} // s3 ist ungültig und wird freigegeben, s2 wird verschoben, s1 ist ungültig und wird freigegeben.
fn gives_ownership() -> String {
let some_string = String::from("hello");
// some_string wird als gültig deklariert
return some_string;
// some_string wird als Rückgabewert aus der Funktion heraus verschoben
}
fn takes_and_gives_back(a_string: String) -> String {
// a_string wird als gültig deklariert
a_string // a_string wird als Rückgabewert aus der Funktion heraus verschoben
}
Die Eigentümerschaft einer Variable, die als Rückgabewert einer Funktion verwendet wird, wird aus der Funktion heraus und zurück an die aufrufende Stelle verschoben, anstatt direkt ungültig gemacht und freigegeben zu werden.
Referenzen und Ausleihen
Eine Referenz ist ein Konzept, das C++-Entwicklern vertraut ist.
Wenn Sie mit Zeigern vertraut sind, können Sie es sich als eine Art Zeiger vorstellen.
Im Wesentlichen ist eine "Referenz" eine indirekte Möglichkeit, auf eine Variable zuzugreifen.
Beispiel
let s1 = String::from("hello");
let s2 = &s1;
println!("s1 ist {}, s2 ist {}", s1, s2);
}
Ausgabe:
s1 is hello, s2 is hello
&Der Operator kann eine "Referenz" auf eine Variable nehmen.
Wenn der Wert einer Variable referenziert wird, wird die Variable selbst nicht als ungültig betrachtet. Das liegt daran, dass eine "Referenz" den Wert der Variable nicht auf dem Stack kopiert:

Dasselbe Prinzip gilt für die Übergabe von Funktionsparametern:
Beispiel
let s1 = String::from("hello");
let len = calculate_length(&s1);
println!("Die Länge von '{}' ist {}.", s1, len);
}
fn calculate_length(s: &String) -> usize {
s.len()
}
Ausgabe:
The length of 'hello' is 5.
Referenzen erlangen kein Eigentum an einem Wert.
Referenzen können nur das Eigentum an einem Wert ausleihen.
Eine Referenz ist selbst ebenfalls ein Typ und hat einen Wert. Dieser Wert speichert die Position eines anderen Werts, aber die Referenz besitzt den referenzierten Wert nicht:
Beispiel
let s1 = String::from("hello");
let s2 = &s1;
let s3 = s1;
println!("{}", s2);
}
Dieses Programm ist fehlerhaft: Weil s1, von dem s2 ausgeliehen hat, sein Eigentum bereits an s3 übertragen hat, wird s2 nicht mehr in der Lage sein, weiterhin das Eigentum von s1 auszuleihen. Wenn s2 diesen Wert verwenden muss, muss es erneut ausleihen:
Beispiel
let s1 = String::from("hello");
let mut s2 = &s1;
let s3 = s1;
s2 = &s3; // Eigentum von s3 erneut ausleihen
println!("{}", s2);
}
Dieses Programm ist korrekt.
Da Referenzen kein Eigentum besitzen, genießen sie, selbst wenn sie Eigentum ausleihen, nur Nutzungsrechte (das ist dasselbe wie das Mieten eines Hauses).
Wenn du versuchst, das ausgeliehene Recht zum Ändern von Daten auszuüben, wird dies verhindert:
Beispiel
let s1 = String::from("run");
let s2 = &s1;
println!("{}", s2);
s2.push_str("oob"); // Fehler: Das Ändern des ausgeliehenen Werts ist verboten
println!("{}", s2);
}
In diesem Programm wird der Versuch von s2, den Wert von s1 zu ändern, verhindert; ausgeliehene Eigentümerschaft kann den Wert des Eigentümers nicht ändern.
Natürlich gibt es auch eine veränderliche Ausleihmethode. Genau wie wenn du ein Haus mietest: Wenn die Immobilienvorschriften es dem Eigentümer erlauben, die Struktur des Hauses zu verändern, und der Eigentümer im Vertrag außerdem erklärt, dass dir dieses Recht während der Mietzeit gewährt wird, kannst du das Haus renovieren:
Beispiel
let mut s1 = String::from("run");
// s1 ist veränderlich
let s2 = &mut s1;
// s2 ist eine veränderliche Referenz
s2.push_str("oob");
println!("{}", s2);
}
Dieses Programm ist in Ordnung. Wir verwenden `&mut`, um veränderliche Referenztypen zu kennzeichnen.
Im Vergleich zu unveränderlichen Referenzen erlauben veränderliche Referenzen neben den unterschiedlichen Berechtigungen keine mehrfachen Referenzen, während unveränderliche Referenzen dies tun:
Beispiel
let r1 = &mut s;
let r2 = &mut s;
println!("{}, {}", r1, r2);
Dieses Programm ist nicht korrekt, weil s mehrere veränderliche Referenzen hat.
Der Entwurf veränderlicher Referenzen in Rust ist hauptsächlich von Überlegungen zu Datenzugriffskollisionen bei Nebenläufigkeit motiviert und verhindert, dass solche Dinge bereits zur Kompilierungszeit passieren.
Da eine der notwendigen Bedingungen für eine Datenzugriffskollision darin besteht, dass die Daten von mindestens einem Nutzer geschrieben und gleichzeitig von mindestens einem anderen Nutzer gelesen oder geschrieben werden, darf ein Wert nicht von irgendeiner anderen Referenz referenziert werden, während er veränderlich referenziert wird.
Hängende Referenzen
Dies ist ein Konzept mit einem anderen Namen. In Programmiersprachen mit dem Konzept der Zeiger bezeichnet es einen Zeiger, der nicht tatsächlich auf wirklich zugängliche Daten zeigt (Hinweis: Er ist nicht unbedingt ein Nullzeiger; er könnte auch eine bereits freigegebene Ressource sein). Sie sind wie Seile, die das Objekt verloren haben, an dem sie hängen, daher der Name "hängende Referenz".
"Hängende Referenzen" sind in Rust nicht erlaubt; wenn sie existieren, wird der Compiler sie erkennen.
Nachfolgend ein typisches Beispiel für eine hängende Referenz:
Beispiel
let reference_to_nothing = dangle();
}
fn dangle() -> &String {
let s = String::from("hello");
&s
}
Offensichtlich wird beim Ende der Funktion `dangle` der Wert ihrer lokalen Variable nicht als Rückgabewert verwendet und freigegeben. Stattdessen wird jedoch ihre Referenz zurückgegeben. Es kann nicht mehr bestätigt werden, dass der Wert, auf den diese Referenz zeigt, existiert, daher ist dies nicht erlaubt.
Andere Erweiterungen