Die häufigsten Fehler von Rust-Anfängern: von A bis Z

Die häufigsten Fehler von Rust-Anfängern: von A bis Z

Rust ist eine leistungsstarke und sichere Programmiersprache, aber ihr strenges System von Ownership und Borrowing stellt Anfänger oft vor Rätsel. In diesem Artikel analysieren wir die häufigsten Fehler, auf die Rust-Anfänger stoßen. Jeder Fehler wird mit einem Codebeispiel, einer Erklärung und der richtigen Lösung begleitet. Los geht's!

1. Ignorieren des Ownership-Systems

Der häufigste Fehler ist der Versuch, einen Wert nach seiner Verschiebung zu verwenden. In Rust kann jeder Wert nur einen Besitzer haben.

❌ Fehlerhafter Code:

fn main() {\n    let s1 = String::from("hallo");\n    let s2 = s1;\n    println!("{}", s1); // Fehler! s1 besitzt den String nicht mehr\n}\n

✅ Richtige Lösung:

fn main() {\n    let s1 = String::from("hallo");\n    let s2 = s1.clone(); // Explizites Kopieren\n    println!("{}", s1); // Funktioniert jetzt\n    println!("{}", s2);\n}\n

Tipp: Verwenden Sie .clone() nur, wenn es wirklich nötig ist. Bei primitiven Typen (i32, bool) erfolgt das Kopieren automatisch.

2. Verwechslung von String und &str

Anfänger verstehen oft den Unterschied zwischen dem besitzenden String String und dem String-Slice &str nicht. Dies führt zu Fehlern bei der Übergabe von Strings an Funktionen.

❌ Fehlerhafter Code:

fn print_message(msg: String) {\n    println!("{}", msg);\n}\n\nfn main() {\n    let greeting = "Guten Tag"; // &str\n    print_message(greeting); // Fehler! String erwartet\n}\n

✅ Richtige Lösung:

fn print_message(msg: &str) {\n    println!("{}", msg);\n}\n\nfn main() {\n    let greeting = "Guten Tag";\n    print_message(greeting); // Funktioniert!\n    \n    let owned = String::from("Welt");\n    print_message(&owned); // &String wird automatisch in &str umgewandelt\n}\n

Goldene Regel: Verwenden Sie in Funktionsparametern &str, wenn Sie das Eigentum am String nicht übertragen müssen.

3. Verletzung der Borrowing-Regeln

Rust erlaubt nicht, gleichzeitig eine veränderliche und eine unveränderliche Referenz auf dasselbe Objekt zu haben. Dies schützt vor Datenrennen.

❌ Fehlerhafter Code:

fn main() {\n    let mut data = vec![1, 2, 3];\n    let ref1 = &data;\n    let ref2 = &mut data; // Fehler! Es gibt bereits eine unveränderliche Referenz\n    println!("{}", ref1);\n}\n

✅ Richtige Lösung:

fn main() {\n    let mut data = vec![1, 2, 3];\n    {\n        let ref1 = &data;\n        println!("{}", ref1); // ref1 lebt nur in diesem Block\n    } // ref1 verlässt den Gültigkeitsbereich\n    let ref2 = &mut data; // Jetzt möglich\n    ref2.push(4);\n    println!("{:?}", ref2);\n}\n

Wichtig: Der Gültigkeitsbereich einer Referenz endet mit ihrer letzten Verwendung. Der Rust-Compiler ist intelligent genug, dies zu verfolgen.

4. Probleme mit Lebenszeiten (Lifetimes)

Fehler im Zusammenhang mit Lifetime-Annotationen erschrecken Anfänger am meisten. Der typischste Fehler ist die Rückgabe einer Referenz auf eine lokale Variable.

❌ Fehlerhafter Code:

fn get_reference() -> &str {\n    let local = String::from("test");\n    &local // Fehler! local wird nach Verlassen der Funktion zerstört\n}\n

✅ Richtige Lösung (durch Ownership):

fn get_reference() -> String {\n    let local = String::from("test");\n    local // Ownership zurückgeben\n}\n\nfn main() {\n    let s = get_reference();\n    println!("{}", s);\n}\n

✅ Richtige Lösung (durch Parameter):

fn get_reference<'a>(input: &'a str) -> &'a str {\n    input // Referenz mit derselben Lebenszeit zurückgeben\n}\n\nfn main() {\n    let data = String::from("test");\n    let result = get_reference(&data);\n    println!("{}", re