Generischen Code in Rust schreiben
Lernen Sie, Funktionen und Datenstrukturen zu schreiben, die mit mehreren Typen funktionieren und so die Wiederverwendbarkeit erhöhen, ohne Typsicherheit einzubüßen.
Generischen Code in Rust schreiben ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.
Warum generischen Code schreiben?
Stellen Sie sich vor, Sie benötigen eine Funktion, die das größte Element in einer Liste findet. Was ist, wenn Sie sie zunächst für Zahlen, dann für Zeichen und anschließend für benutzerdefinierte Objekte benötigen?
Ohne Generics müssten Sie für jeden Typ eine eigene Funktion schreiben, was zu viel doppeltem Code führen würde. Hier kommen Generics ins Spiel!
Generics kennenlernen
Mit Generics können Sie Code schreiben, der mit mehreren Typen funktioniert, ohne sich zu wiederholen. Sie ermöglichen flexible und wiederverwendbare Funktionen oder Datenstrukturen.
Stellen Sie sich Generics als eine Vorlage vor, die an unterschiedliche Materialien angepasst werden kann.
Ihre erste generische Funktion
Um eine Funktion generisch zu machen, deklarieren wir Typparameter in spitzen Klammern <> hinter dem Funktionsnamen. Ein gängiger Name für einen Typparameter ist T (für Type).
Diese Funktion print_anything kann nun jeden Typ ausgeben!
fn print_anything<T>(item: T) {
println!("The item is: {}", item);
}
pub fn main() {
print_anything(5);
print_anything("hello");
print_anything(true);
}Typparameter erklärt
Das <T> in fn print_anything<T>(item: T) bedeutet, dass T ein Platzhalter für einen Typ ist. Wenn Sie die Funktion mit einem i32 aufrufen, wird T zu i32.
- Typparameter: Generische Typen werden normalerweise mit Großbuchstaben wie
T,UundVbenannt. - Flexibilität: Der Compiler ermittelt den konkreten Typ zur Compilezeit.
Verhalten hinzufügen: Trait Bounds
Manchmal muss der Typparameter T Ihrer generischen Funktion bestimmte Verhaltensweisen besitzen. Wenn Sie beispielsweise zwei T-Werte vergleichen möchten, muss T vergleichbar sein.
Wir fügen Trait Bounds hinzu, um diese Anforderungen festzulegen. Hier bedeutet T: PartialOrd + Copy, dass T die Traits PartialOrd (partielle Ordnung zum Vergleichen) und Copy implementieren muss.
fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
let mut largest = list[0];
for &item in list.iter() {
if item > largest {
largest = item;
}
}
largest
}
pub fn main() {
let number_list = vec![34, 50, 25, 100, 65];
println!("Largest number: {}", largest(&number_list));
let char_list = vec!['y', 'm', 'a', 'q'];
println!("Largest char: {}", largest(&char_list));
}Syntax für mehrere Trait Bounds
Sie können für einen generischen Typ mehrere Traits verlangen, indem Sie die Syntax mit + verwenden, zum Beispiel T: TraitA + TraitB.
Für komplexe Bounds können Sie nach der Funktionssignatur auch eine where-Klausel verwenden. Dadurch kann die Signatur übersichtlicher werden:
fn some_function<T, U>(t: T, u: U) -> i32 where T: Display + Clone, U: Clone + Debug { /* ... */ }
Generische Structs
Wie bei Funktionen können Sie Structs für einen oder mehrere Typparameter generisch definieren. Dadurch können Ihre Datenstrukturen Daten jedes angegebenen Typs aufnehmen.
Das Struct Point<T> kann Koordinaten jedes Typs T aufnehmen (z. B. i32 oder f64).
struct Point<T> {
x: T,
y: T,
}
pub fn main() {
let integer_point = Point {
x: 5,
y: 10
};
let float_point = Point {
x: 1.0,
y: 4.0
};
println!("Int Point: ({}, {})",
integer_point.x, integer_point.y);
println!("Float Point: ({}, {})",
float_point.x, float_point.y);
}Methoden für generische Structs implementieren
Wenn Sie Methoden für ein generisches Struct implementieren, müssen Sie die generischen Typparameter nach impl angeben.
Sie können Methoden außerdem mit Trait Bounds versehen, wenn eine Methode für ihre generischen Typen ein bestimmtes Verhalten voraussetzt.
struct Point<T> {
x: T,
y: T,
}
impl<T> Point<T> {
fn x(&self) -> &T {
&self.x
}
}
pub fn main() {
let p = Point {
x: 5,
y: 10
};
println!("p.x = {}", p.x());
}Generics und Performance
Eine der Stärken von Rust besteht darin, dass Generics eine Abstraktion ohne Laufzeitkosten sind. Das bedeutet, dass die Verwendung von Generics keine Leistungseinbußen zur Laufzeit verursacht.
Rust erreicht dies durch Monomorphisierung: Zur Compilezeit erzeugt der Compiler für jeden konkreten Typ, mit dem der generische Code verwendet wird, eine spezialisierte Version. Dadurch werden largest<i32> und largest<char> zu zwei unterschiedlichen, optimierten Funktionen.
Testen Sie Ihr Wissen
Welche der folgenden Aussagen über Generics in Rust sind RICHTIG?
Zusammenfassung: Die Stärke von Generics
In dieser Lektion haben Sie die Grundlagen des Schreibens von generischem Code in Rust gelernt:
- Was sie sind: Eine Möglichkeit, flexiblen und wiederverwendbaren Code zu schreiben.
- Generische Funktionen: Verwendung von
<T>für Typparameter. - Trait Bounds: Festlegen erforderlicher Verhaltensweisen mit
T: Trait. - Generische Structs: Erstellen von Datenstrukturen, die generische Typen aufnehmen.
- Keine Laufzeitkosten: Rust kompiliert Generics zu spezifischem Code und stellt so sicher, dass keine Leistungseinbußen zur Laufzeit entstehen.
Generics sind ein Grundpfeiler idiomatischen Rust-Codes und ermöglichen leistungsfähige, typsichere Abstraktionen!
Häufig gestellte Fragen
Ist die Lektion „Generischen Code in Rust schreiben“ kostenlos?
Ja — der vollständige Text von „Generischen Code in Rust schreiben“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.
Was lerne ich in „Generischen Code in Rust schreiben“?
Lernen Sie, Funktionen und Datenstrukturen zu schreiben, die mit mehreren Typen funktionieren und so die Wiederverwendbarkeit erhöhen, ohne Typsicherheit einzubüßen. Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Learn Rust Coding zu starten?
Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.
Wie lange dauert die Lektion „Generischen Code in Rust schreiben“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?
Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Generischen Code in Rust schreiben
- Traits definieren und implementieren
- Fortgeschrittene Trait-Nutzung: Associated Types