Was ist das Ownership-Modell in Rust?

Die drei Ownership-Regeln

Das offizielle Rust-Buch fasst das Modell in drei Sätzen zusammen. Alles Weitere, Move, Ausleihen und Lebensdauern, folgt aus ihnen:

1. 1

   Jeder Wert hat einen Besitzer

   Ein Wert gehört immer einer Variablen, einem Feld oder einer Sammlung, die für ihn zuständig ist.

2. 2

   Es gibt immer nur einen Besitzer

   Zwei Variablen können nicht gleichzeitig Eigentümer desselben Werts sein. Wechselt die Zuständigkeit, ist die alte Variable ungültig.

3. 3

   Endet der Besitzer, endet der Wert

   Verlässt der Besitzer seinen Gültigkeitsbereich, ruft Rust automatisch drop auf und gibt den Speicher frei, genau einmal.

Die Freigabe am Ende des Gültigkeitsbereichs gilt nicht nur für Speicher. Dateien, Netzwerkverbindungen und Sperren hängen in Rust ebenfalls an einem Besitzer und werden mit ihm geschlossen, ohne dass ein close im Code stehen muss.

Move: wenn der Besitz wandert

Wenn du einen Wert einer anderen Variablen zuweist oder an eine Funktion übergibst, wandert der Besitz mit. Die alte Variable ist danach nicht mehr benutzbar, der Compiler nennt das moved. Bei einem String wird dabei nichts kopiert, nur die Zuständigkeit für den Speicher auf dem Heap wechselt:

let s1 = String::from("Hallo");
let s2 = s1;            // Besitz wandert von s1 zu s2
println!("{s1}");       // error[E0382]: borrow of moved value: `s1`

Einfache Typen wie Ganzzahlen, Gleitkommazahlen und bool verhalten sich anders. Sie implementieren den Trait Copy und werden bei der Zuweisung bitweise kopiert, beide Variablen bleiben gültig. Für eigene Typen steuerst du das über Copy und Clone, wobei eine tiefe Kopie immer ausdrücklich als clone() im Code steht. Genau deshalb siehst du in Rust, wo kopiert wird, und musst es nicht erraten.

Ausleihen und der Borrow-Checker

Damit nicht ständig Besitz hin- und hergereicht wird, gibt es Referenzen, in Rust Ausleihen (Borrowing) genannt. Die Regel dahinter: Entweder beliebig viele lesende Referenzen (&T) oder genau eine schreibende (&mut T), nie beides gleichzeitig. Dazu muss jede Referenz kürzer leben als der Wert, auf den sie zeigt. Der Borrow-Checker prüft beides beim Übersetzen:

let mut liste = vec![1, 2, 3];
let erstes = &liste[0];   // lesende Ausleihe
liste.push(4);            // error[E0502]: cannot borrow `liste` as mutable
                          // because it is also borrowed as immutable
println!("{erstes}");

Das Beispiel zeigt, welchen Fehler die Regel verhindert. push kann den Vektor an eine neue Stelle im Speicher verschieben, wenn der Platz nicht mehr reicht. Die Referenz erstes würde dann auf freigegebenen Speicher zeigen, in C++ ein klassischer, schwer zu findender Absturz. Rust baut das Programm gar nicht erst.

Wie lange eine Referenz gültig bleiben muss, beschreiben Lebensdauern (Lifetimes). In den meisten Fällen leitet der Compiler sie selbst ab, eine Angabe wie 'a brauchst du erst, wenn eine Funktion mehrere Referenzen bekommt und nicht eindeutig ist, an welcher die Rückgabe hängt.

Geteilter Besitz, wenn er wirklich nötig ist

Manche Datenstrukturen haben keinen natürlichen einzelnen Besitzer, etwa ein Graph oder ein Zustand, den mehrere Threads lesen. Dafür bringt die Standardbibliothek Typen mit, die einen Teil der Prüfung bewusst in die Laufzeit verschieben:

Typische Kombinationen sind Rc<RefCell<T>> in einem Thread und Arc<Mutex<T>> über Threads. Sie sind kein Notausgang, aber auch nicht der erste Griff: Wer sie überall einsetzt, hat meist ein Datenmodell aus einer anderen Sprache übernommen, in dem viele Stellen dieselbe Struktur ändern.