cat posts/rust-lernen-03-ownership.md
Rust lernen (Teil 3): Ownership
Jeder Wert hat genau einen Besitzer, und wenn der geht, wird der Wert freigegeben. Was das für Zuweisungen und Funktionsaufrufe heißt, warum String nicht kopiert wird und wie logbuch einen Fehlerbericht baut.
In Teil 1 stand ein Satz, den Du vielleicht
ausprobiert hast: Lass das & bei &pfad weg, dann meldet sich der Compiler.
Heute wird das eingelöst. Aus fs::read_to_string(&pfad) wird
fs::read_to_string(pfad):
error[E0382]: borrow of moved value: `pfad`
--> src/main.rs:15:16
|
5 | let pfad = env::args().nth(1).expect("Aufruf: logbuch <DATEI>");
| ---- move occurs because `pfad` has type `String`, which does not implement the `Copy` trait
6 | let text = fs::read_to_string(pfad).expect("Datei nicht lesbar");
| ---- value moved here
...
15 | println!("{pfad}: {zeilen} Zeilen, davon {fehler} Fehler ({anteil:.1} %)");
| ^^^^ value borrowed here after move
|
help: consider borrowing `pfad`
|
6 | let text = fs::read_to_string(&pfad).expect("Datei nicht lesbar");
| +
Zeile 6 übergibt pfad an eine Funktion. Danach gehört der Wert der Funktion,
und main darf ihn in Zeile 15 nicht mehr anfassen. In Python wäre das absurd:
Ein Name, den Du einer Funktion übergibst, ist danach immer noch da. Um diesen
Unterschied geht es in diesem Teil. Das Konzept dahinter heißt Ownership.
Die Regeln
Ownership lässt sich in drei Sätzen aufschreiben:
- Jeder Wert hat einen Besitzer, meist eine Variable.
- Es gibt immer genau einen Besitzer.
- Verlässt der Besitzer seinen Gültigkeitsbereich, wird der Wert freigegeben.
Der Rest dieses Teils sind Folgerungen daraus. Der Gültigkeitsbereich (Scope)
einer Variablen ist der Block in geschweiften Klammern, in dem sie steht. Am
Ende von main endet der Scope (Gültigkeitsbereich) von pfad und text, und
Rust gibt den Speicher frei.
Wie Python das macht
In Python sind Namen nur Verweise. Zwei Namen können auf dasselbe Objekt zeigen:
logs = ["access.log"]
alias = logs
alias.append("error.log")
print(logs) # ['access.log', 'error.log']
Wann die Liste freigegeben wird, entscheidet CPython über einen Zähler: Jedes Objekt weiß, wie viele Verweise es gibt. Fällt der Zähler auf null, ist das Objekt weg. Für Zyklen, deren Zähler nie auf null fallen, läuft zusätzlich ein Garbage Collector. Das kostet Speicher für die Zähler und Zeit für das Zählen, nimmt Dir aber jede Buchführung ab.
Rust hat keinen Garbage Collector und zählt Verweise nur, wenn Du es
ausdrücklich verlangst (dafür gibt es den Typ Rc). Stattdessen legt der
Compiler beim Übersetzen fest, wann jeder Wert freigegeben wird. Das geht nur,
weil es immer genau einen Besitzer gibt: Dessen Scope-Ende ist der Zeitpunkt.
Verschieben
Was passiert dann bei einer Zuweisung?
fn main() {
let a = String::from("access.log");
let b = a;
println!("{a} {b}");
}
error[E0382]: borrow of moved value: `a`
--> src/main.rs:4:16
|
2 | let a = String::from("access.log");
| - move occurs because `a` has type `String`, which does not implement the `Copy` trait
3 | let b = a;
| - value moved here
4 | println!("{a} {b}");
| ^ value borrowed here after move
|
help: consider cloning the value if the performance cost is acceptable
|
3 | let b = a.clone();
| ++++++++
let b = a macht b zum neuen Besitzer. Das heißt Verschieben (Move): Der
Wert wechselt den Besitzer, und a ist danach ungültig. Gäbe es zwei Besitzer,
würden am Ende beide den Speicher freigeben wollen. Das wäre in C ein Double
Free, einer der Klassiker unter den Sicherheitslücken. Rust verhindert ihn,
indem es den alten Namen sperrt.
String::from("access.log") macht übrigens aus dem Literal einen eigenen
String. Warum das nötig ist, kommt weiter unten.
Kopieren: Copy und clone
Mit Zahlen klappt dasselbe ohne Murren:
let status: u16 = 404;
let kopie = status;
println!("{status} {kopie}");
u16 ist Copy. Typen mit dieser Eigenschaft werden bei einer Zuweisung bitweise
kopiert, und beide Variablen bleiben gültig. Copy sind unter anderem alle
Zahltypen, bool, char und Tupel oder Arrays, die nur aus Copy-Typen
bestehen. Die Fehlermeldung oben nennt Copy ein Merkmal (Trait). Was das
genau ist, klärt Teil 10geplant.
Ein String ist nicht Copy, weil er Speicher besitzt. Er besteht aus zwei
Teilen. Auf dem
Stapelspeicher (Stack) liegen ein Zeiger, die Länge und die Kapazität. Die
eigentlichen Zeichen liegen im Freispeicher (Heap). Eine bitweise Kopie
würde nur den Zeiger verdoppeln, und dann zeigten zwei Besitzer auf dieselben
Zeichen. Genau das sollen die Regeln verhindern. Was das im Speicher genau
heißt und wie Python das löst, misst der Begleitartikel
Stack und Heapgeplant nach.
Willst Du wirklich eine Kopie, sagst Du es: a.clone() legt einen neuen
Speicherbereich im Heap (Freispeicher) an und kopiert die Zeichen hinein. Der
Compiler schlägt das vor, sagt aber auch dazu: „if the performance cost is
acceptable“. Bei einem Dateinamen ist das egal. Bei einem Log mit 2 GB wäre ein clone pro
Funktionsaufruf eine schlechte Idee.
Funktionen nehmen und geben
Ein Funktionsaufruf ist ein Move (Verschieben) wie eine Zuweisung. Angenommen,
zaehle_zeilen nimmt einen String statt &str:
fn zaehle_zeilen(text: String) -> usize {
text.lines().count()
}
fn main() {
let text = String::from("eins\nzwei\n");
let zeilen = zaehle_zeilen(text);
println!("{zeilen} Zeilen, {} Bytes", text.len());
}
error[E0382]: borrow of moved value: `text`
--> src/main.rs:8:43
|
6 | let text = String::from("eins\nzwei\n");
| ---- move occurs because `text` has type `String`, which does not implement the `Copy` trait
7 | let zeilen = zaehle_zeilen(text);
| ---- value moved here
8 | println!("{zeilen} Zeilen, {} Bytes", text.len());
| ^^^^ value borrowed here after move
|
note: consider changing this parameter type in function `zaehle_zeilen` to borrow instead if owning the value isn't necessary
--> src/main.rs:1:24
|
1 | fn zaehle_zeilen(text: String) -> usize {
| ------------- ^^^^^^ this parameter takes ownership of the value
| |
| in this function
...
Der Parameter text ist jetzt Besitzer. Am Ende von zaehle_zeilen endet sein
Scope, und der Text wird freigegeben, noch bevor main die Bytes zählen kann.
Die note: zeigt schon die richtige Lösung: Die Funktion braucht den Text gar
nicht zu besitzen, sie will ihn nur lesen.
Besitz kann auch aus einer Funktion hinauswandern, über den Rückgabewert. Eine Funktion kann einen Wert anlegen und ihn an den Aufrufer abgeben:
fn kopfzeile(pfad: &str) -> String {
let zeile = format!("Auswertung von {pfad}");
zeile
}
zeile gehört der Funktion. Gäbe sie zeile nicht zurück, würde der String
am Ende freigegeben. So aber wandert er hinaus zum Aufrufer, der jetzt sein Besitzer
ist. Kürzer wäre format! direkt als letzter Ausdruck. Für die Erklärung ist
die Variable deutlicher.
Ein hübsches Detail zeigt, wie ernst Rust das meint. Die Funktion drop gibt
einen Wert sofort frei, und so ist sie in der Standardbibliothek definiert:
pub fn drop<T>(_x: T) {}
Sie tut nichts. Sie nimmt den Wert in Besitz, und weil der Scope von _x sofort endet,
wird er freigegeben. Benutzt Du text nach drop(text), kommt wieder E0382.
Der Compiler schlägt dann ernsthaft drop(text.clone()) vor, was zwar
kompiliert, aber den Sinn der Übung verfehlt.
Wann wird freigegeben?
Mit drop gibst Du einen Wert vorzeitig frei. Sonst passiert das am Ende des
Scopes, und zwar im Normalfall an einer Stelle, die schon beim Kompilieren
feststeht:
fn main() {
let pfad = String::from("access.log");
{
let text = String::from("…");
println!("{pfad}: {} Bytes", text.len());
} // text wird hier freigegeben
println!("{pfad}");
} // pfad wird hier freigegeben
In CPython ist das bei einfachen Fällen ähnlich deterministisch, weil der Zähler
auf null fällt, sobald der letzte Verweis verschwindet. Bei Zyklen entscheidet
aber der Garbage Collector, und der läuft, wann er will. In Rust gibt es diesen
Fall nur, wenn Du selbst mit Rc zählen lässt. Das Freigeben am Scope-Ende gilt
auch für andere Ressourcen: Eine offene Datei wird am
Scope-Ende geschlossen, ein Lock freigegeben. Pythons with erledigt dasselbe,
nur musst Du dort daran denken, es hinzuschreiben.
String und &str
Seit Teil 1 laufen zwei Texttypen mit. Jetzt ergibt ihr Unterschied Sinn:
Stringbesitzt seine Zeichen. Sie liegen im Heap, derStringkann wachsen und gibt sie frei, wenn sein Besitzer geht.&strist ein geliehener Blick auf Zeichen, die ihm nicht gehören. Ein&strgibt nichts frei.
Ein Literal wie "access.log" ist ein &str. Die Zeichen stehen fest im
Programm und gehören niemandem, der sie freigeben müsste. Einen eigenen,
veränderbaren Text bekommst Du deshalb nur über String::from("access.log")
oder "access.log".to_string().
Pythons str ist unveränderlich. Ein Rust-String lässt sich dagegen erweitern,
etwa mit push_str, wenn die Variable mut ist. Das braucht logbuch gleich.
Die Funktionen in logbuch nehmen alle &str, weil sie nur lesen. Und weil
sich ein &String automatisch in ein &str verwandeln lässt, kannst Du ihnen
&text genauso übergeben wie ein Literal. Wie das Leihen genau funktioniert,
ist Thema des nächsten Teilsgeplant.
logbuch: der Fehlerbericht
logbuch soll jetzt nicht nur zählen, sondern auch zeigen, welche Anfragen
gescheitert sind. Die neue Funktion baut dafür einen Text zusammen und gibt ihn
ab:
fn fehlerbericht(text: &str) -> String {
let mut bericht = String::new();
for zeile in text.lines() {
let status = statuscode(zeile);
if status >= 400 {
let pfad = zeile.split_whitespace().nth(6).expect("Zeile ohne Pfad");
bericht.push_str(&format!(" {status} {pfad}\n"));
}
}
bericht
}
fehlerbericht leiht sich den Text (&str) und besitzt den Bericht
(String). String::new() legt einen leeren String an, der wachsen kann. push_str
hängt etwas an, so wie += bei einem Python-String, nur ohne jedes Mal ein
neues Objekt zu erzeugen. format! liefert einen neuen String, und push_str
will einen &str, daher das &. Am Ende verlässt bericht die Funktion als
Rückgabewert, und main wird Besitzer. Der Pfad steht an Index 6, zwischen
Methode und Protokoll.
In main kommen zwei Zeilen dazu:
let bericht = fehlerbericht(&text);
print!("{bericht}");
print! ist println! ohne Zeilenumbruch am Ende, den hat jede Berichtszeile
schon. Dazu zwei Tests im Modul tests:
#[test]
fn bericht_nennt_fehlerhafte_pfade() {
let text = format!("{ZEILE_200}\n{ZEILE_404}\n");
assert_eq!(fehlerbericht(&text), " 404 /wp-login.php\n");
}
#[test]
fn bericht_ohne_fehler_ist_leer() {
assert_eq!(fehlerbericht(ZEILE_200), "");
}
assert_eq! vergleicht hier einen String mit einem Literal, also mit einem
&str. Das geht, weil Rust für diese Kombination einen Vergleich mitbringt.
$ cargo test
...
test result: ok. 8 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
$ cargo run -- access.log
...
access.log: 5 Zeilen, davon 2 Fehler (40.0 %)
404 /favicon.ico
404 /wp-login.php
Der Rest von main.rs ist unverändert gegenüber
Teil 2.
Übungen
1. Was kompiliert? Überlege für jede der drei println!-Zeilen, ob sie
kompiliert, bevor Du es ausprobierst.
fn main() {
let status: u16 = 404;
let kopie = status;
println!("{status} {kopie}");
let pfad = String::from("/favicon.ico");
let kopie = pfad;
println!("{pfad} {kopie}");
let literal = "/favicon.ico";
let kopie = literal;
println!("{literal} {kopie}");
}
Lösung
Nur die mittlere scheitert, mit E0382 für `pfad`. `u16` ist `Copy`. Das Überraschende ist die dritte: Auch `&str` ist `Copy`. Kopiert wird dabei nur der Verweis, nicht die Zeichen, und einen Verweis darf es beliebig oft geben, weil er nichts freigibt. Die Zeile `let kopie = …` funktioniert dreimal hintereinander dank Shadowing.2. Was gibt das aus?
fn main() {
let a = String::from("außen");
{
let b = String::from("innen");
let a = b;
println!("{a}");
}
println!("{a}");
}
Lösung
innen
außen
3. Hin und zurück. Schreib fehlerbericht so um, dass das Anhängen in einer
eigenen Funktion ergaenze passiert, die den Bericht als String übernimmt und
wieder zurückgibt. Was fällt Dir am Aufruf auf?
Lösung
fn ergaenze(mut bericht: String, status: u16, pfad: &str) -> String {
bericht.push_str(&format!(" {status} {pfad}\n"));
bericht
}
Im nächsten Teil
Die bessere Lösung heißt Ausleihen (Borrowing). Mit & und &mut bekommt
eine Funktion Zugriff auf einen Wert, ohne ihn zu besitzen. Dafür gelten eigene
Regeln, die der Compiler streng prüft. Teil 4geplant zeigt sie und erklärt, warum
logbuch damit ohne eine einzige Kopie auskommt.
Tastenkürzel
- j k
- nach unten / oben scrollen
- n p
- nächster / vorheriger Abschnitt
- g G
- Anfang / Ende des Artikels
- t
- Gliederung zeigen
- ?
- diese Hilfe zeigen
- Esc
- schließen
0 Kommentare
Noch keine Kommentare. Sei der/die Erste!
Anmelden um einen Kommentar zu hinterlassen.