Rust - Arrays und Vektoren

Arrays und Vektoren sind die grundlegenden Datentypen in Rust, wenn es um die Speicherung von Listen geht. Arrays sind effizient für fixe Datenmengen, während Vektoren (Vec) für dynamisch wachsende oder schrumpfende Listen ideal sind. Rusts strikte Regeln zum Borrowing und Ownership helfen dabei, Fehler in der Speicherverwaltung zu vermeiden und die Sicherheit zur Laufzeit zu gewährleisten.

1. Arrays in Rust

Ein Array ist eine feste, unveränderliche Sammlung von Werten desselben Typs. Die Größe eines Arrays wird zur Kompilierungszeit festgelegt und kann später nicht mehr geändert werden.

Beispiel: Array erstellen

fn main() {
    let numbers: [i32; 5] = [1, 2, 3, 4, 5];
    println!("{:?}", numbers);
}

In diesem Beispiel wird ein Array numbers erstellt, das aus fünf Ganzzahlen (i32) besteht. Die Größe [i32; 5] gibt an, dass das Array fünf Elemente hat.

Eigenschaften von Arrays

• Feste Größe: Die Größe eines Arrays wird beim Erstellen festgelegt und kann nicht geändert werden.
• Zugriff auf Elemente: Der Zugriff auf Array-Elemente erfolgt über Indizes, beginnend bei 0.
• Stack-gespeichert: Elemente werden auf dem Stack gespeichert.

Beispiel: Zugriff auf Array-Elemente

fn main() {
    let numbers = [1, 2, 3, 4, 5];
    println!("Erstes Element: {}", numbers[0]);
    println!("Drittes Element: {}", numbers[2]);
}

Rust überprüft, ob der Index innerhalb der Array-Grenzen liegt. Wenn versucht wird, auf einen ungültigen Index zuzugreifen, wird das Programm mit einem Panik-Fehler beendet.

2. Vektoren (Vec)

Ein Vektor (Vec<T>) in Rust ist eine dynamisch veränderbare Liste von Elementen. Im Gegensatz zu Arrays kann die Größe eines Vektors zur Laufzeit geändert werden, indem Elemente hinzugefügt oder entfernt werden.

Beispiel: Vektor erstellen

fn main() {
    let mut numbers = Vec::new();
    numbers.push(1);
    numbers.push(2);
    numbers.push(3);
    println!("{:?}", numbers);
}

In diesem Beispiel wird ein leerer Vektor numbers erstellt, und dann werden Elemente mit der Methode push hinzugefügt.

Eigenschaften von Vektoren

• Dynamische Größe: Vektoren können zur Laufzeit vergrößert oder verkleinert werden.
• Heap-gespeichert: Im Gegensatz zu Arrays werden Vektoren im Heap gespeichert, was es ermöglicht, die Größe zur Laufzeit zu ändern.
• Mutabilität: Ein Vektor muss als mut deklariert werden, wenn er verändert werden soll.

Beispiel: Zugriff auf Vektorelemente

fn main() {
    let numbers = vec![10, 20, 30, 40];
    println!("Zweites Element: {}", numbers[1]);
}

Beispiel: Elemente entfernen

fn main() {
    let mut numbers = vec![1, 2, 3, 4];
    numbers.pop(); // Letztes Element entfernen
    println!("{:?}", numbers); // Gibt: [1, 2, 3]
}

3. Unterschiede in der Nutzung

fn main() {
    let array = [1, 2, 3];   // Festes Array
    let mut vector = vec![1, 2, 3]; // Dynamischer Vektor

    vector.push(4);          // Hinzufügen eines Wertes (nur bei Vec)
    println!("{:?}", array);
    println!("{:?}", vector);
}

4. Iteration über Arrays und Vektoren

Sowohl über Arrays als auch über Vektoren kann mit einer for-Schleife iteriert werden.

Beispiel: Iteration über ein Array

fn main() {
    let numbers = [10, 20, 30];
    for num in numbers.iter() {
        println!("Wert: {}", num);
    }
}

Beispiel: Iteration über einen Vektor

fn main() {
    let numbers = vec![5, 10, 15];
    for num in &numbers {
        println!("Wert: {}", num);
    }
}

Bei Vektoren wird eine Referenz &numbers verwendet, um sicherzustellen, dass der Vektor nicht konsumiert wird und weiterhin verwendet werden kann.