Rust Vektoren: Grundlagen vergrößerbarer Arrays

Einführung

In diesem Lab lernen wir über Vektoren, die in Rust als vergrößerbare Arrays implementiert sind und sich jederzeit erweitern oder verkleinern können. Ein Vektor wird durch drei Parameter dargestellt: einen Zeiger auf die Daten, die Länge und die Kapazität. Die Kapazität gibt an, wie viel Speicher für den Vektor reserviert ist, und wenn die Länge die Kapazität überschreitet, wird der Vektor mit einer größeren Kapazität neu zugewiesen. Wir können Iteratoren in Vektoren sammeln, indem wir die collect-Methode verwenden, Vektoren mit der vec!-Makro initialisieren, neue Elemente am Ende hinzufügen, indem wir die push-Methode verwenden, und die Anzahl der Elemente mit der len-Methode abrufen. Wir können auch auf Elemente über den Index zugreifen, das letzte Element entfernen, indem wir die pop-Methode verwenden, und über den Vektor iterieren, indem wir die iter- oder iter_mut-Methoden verwenden. Darüber hinaus stehen in das std::vec-Modul weitere Methoden für Vektoren zur Verfügung.

Hinweis: Wenn im Lab kein Dateiname angegeben ist, können Sie einen beliebigen Dateinamen verwenden. Beispielsweise können Sie main.rs verwenden und es mit rustc main.rs &&./main kompilieren und ausführen.

Vektoren

Vektoren sind vergrößerbare Arrays. Wie Slices ist ihre Größe zur Compile-Zeit unbekannt, aber sie können sich jederzeit erweitern oder verkleinern. Ein Vektor wird durch 3 Parameter dargestellt:

• Zeiger auf die Daten
• Länge
• Kapazität

Die Kapazität gibt an, wie viel Speicher für den Vektor reserviert ist. Der Vektor kann sich so lange erweitern, wie die Länge kleiner als die Kapazität ist. Wenn diese Schwelle überschritten werden muss, wird der Vektor mit einer größeren Kapazität neu zugewiesen.

fn main() {
    // Iteratoren können in Vektoren gesammelt werden
    let collected_iterator: Vec<i32> = (0..10).collect();
    println!("Gesammelt (0..10) in: {:?}", collected_iterator);

    // Das `vec!`-Makro kann verwendet werden, um einen Vektor zu initialisieren
    let mut xs = vec![1i32, 2, 3];
    println!("Initialer Vektor: {:?}", xs);

    // Füge ein neues Element am Ende des Vektors hinzu
    println!("Füge 4 in den Vektor hinzu");
    xs.push(4);
    println!("Vektor: {:?}", xs);

    // Fehler! Unveränderliche Vektoren können nicht wachsen
    collected_iterator.push(0);
    // FIXME ^ Kommentiere diese Zeile aus

    // Die `len`-Methode liefert die Anzahl der aktuell im Vektor gespeicherten Elemente
    println!("Vektorlänge: {}", xs.len());

    // Der Zugriff erfolgt über eckige Klammern (der Zugriff beginnt bei 0)
    println!("Zweites Element: {}", xs[1]);

    // `pop` entfernt das letzte Element aus dem Vektor und gibt es zurück
    println!("Entferne letztes Element: {:?}", xs.pop());

    // Ein Zugriff außerhalb der Grenzen führt zu einem Absturz
    println!("Viertes Element: {}", xs[3]);
    // FIXME ^ Kommentiere diese Zeile aus

    // Über `Vector`s kann einfach iteriert werden
    println!("Inhalt von xs:");
    for x in xs.iter() {
        println!("> {}", x);
    }

    // Ein `Vector` kann auch iteriert werden, während die Iterationszahl
    // in einer separaten Variable (`i`) aufgelistet wird
    for (i, x) in xs.iter().enumerate() {
        println!("An Position {} haben wir den Wert {}", i, x);
    }

    // Dank `iter_mut` können auch veränderliche `Vector`s iteriert werden,
    // indem jeder Wert modifiziert werden kann
    for x in xs.iter_mut() {
        *x *= 3;
    }
    println!("Aktualisierter Vektor: {:?}", xs);
}

Weitere Vec-Methoden können im std::vec-Modul gefunden werden.

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Vektoren-Lab abgeschlossen. Sie können in LabEx weitere Labs absolvieren, um Ihre Fähigkeiten zu verbessern.