Zum Inhalt springen

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.

Knetfigur: Eine rote Katze sitzt mit missmutiger Miene und geschlossenen Augen in einem Pappkarton, daneben steht ein zweiter, leerer Karton.

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:

  1. Jeder Wert hat einen Besitzer, meist eine Variable.
  2. Es gibt immer genau einen Besitzer.
  3. 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:

  • String besitzt seine Zeichen. Sie liegen im Heap, der String kann wachsen und gibt sie frei, wenn sein Besitzer geht.
  • &str ist ein geliehener Blick auf Zeichen, die ihm nicht gehören. Ein &str gibt 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
Das innere `let a = b` verschiebt `b` in ein neues `a`, das das äußere nur verdeckt. Am Ende des inneren Blocks wird „innen“ freigegeben, und das äußere `a` ist wieder sichtbar. Es wurde nie angefasst.

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
}
`mut` vor dem Parameter macht die Variable in der Funktion veränderbar. Der Aufruf in der Schleife lautet `bericht = ergaenze(bericht, status, pfad);`. Der Bericht wandert hinein und wieder heraus, und das funktioniert. Es ist aber umständlich: Die Funktion will den Bericht nur verändern, nicht besitzen. Dafür gibt es eine bessere Lösung.

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.

0 Kommentare

Noch keine Kommentare. Sei der/die Erste!