Arrays in Rust

Ein Array ist eine Liste mit fester Größe, in der alle Werte denselben Typ haben. Das Entscheidende ist „feste Größe“: Ein einmal erstelltes Array kann weder wachsen noch schrumpfen. Brauchst du etwas, das seine Größe ändern kann, nimmst du einen Vektor.

Ein Array erstellen

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

Den Typ [i32; 5] liest du als „ein Array aus 5 i32-Werten“. Die Länge gehört zum Typ: [i32; 5] und [i32; 3] sind zwei verschiedene Typen.

▶ Selbst ausprobieren

Du kannst den Typ auch von Rust ableiten lassen und einfach die Werte hinschreiben:

let numbers = [1, 2, 3, 4, 5];

Derselbe Wert, mehrfach

Willst du ein Array N-mal mit demselben Wert füllen, gibt es diese Kurzschreibweise:

fn main() {
    let zeros = [0; 5]; // [0, 0, 0, 0, 0]
    println!("{:?}", zeros);
}

▶ Selbst ausprobieren

Auf Elemente zugreifen

Mit eckigen Klammern greifst du auf die Elemente zu. Der Index beginnt bei 0:

fn main() {
    let fruits = ["Apfel", "Banane", "Kirsche"];

    println!("{}", fruits[0]); // Apfel
    println!("{}", fruits[2]); // Kirsche
    println!("Länge: {}", fruits.len());
}

▶ Selbst ausprobieren

Zugriffe außerhalb der Grenzen werden abgefangen

Greifst du auf einen Index zu, den es nicht gibt, hält Rust dein Programm an, statt heimlich irgendwelchen Datenmüll aus dem Speicher zu lesen:

fn get_fruit(fruits: [&str; 3], index: usize) -> &str {
    fruits[index]
}

fn main() {
    let fruits = ["Apfel", "Banane", "Kirsche"];
    println!("{}", get_fruit(fruits, 10)); // Panic zur Laufzeit
}

thread 'main' (12345) panicked at src/main.rs:2:5:
index out of bounds: the len is 3 but the index is 10

Diese Meldung gibt Rust auf Englisch aus. Sie bedeutet: „Index außerhalb der Grenzen: Die Länge ist 3, aber der Index ist 10.“

Hinweis

Das Beispiel übergibt den Index absichtlich über einen Funktionsparameter. Schreibst du fruits[10] direkt mit einem festen Index, merkt der Compiler oft schon beim Kompilieren, dass dieser Zugriff immer ungültig ist, und baut das Programm gar nicht erst. Das ist sogar noch sicherer, zeigt aber keine Panic zur Laufzeit. Erst weil der Index über eine Variable kommt, die der Compiler nicht vollständig vorhersagen kann, wird daraus ein ehrliches Laufzeit-Beispiel.

In einer Sprache wie C ist das Lesen hinter dem Ende eines Arrays undefiniertes Verhalten. Manchmal stürzt das Programm ab, manchmal liest es still, was eben gerade im Speicher dahinter liegt – eine echte Quelle für Sicherheitslücken. Rust prüft die Grenzen bei jedem Zugriff und löst stattdessen eine saubere Panic aus. Das kostet ein wenig, ist aber viel sicherer.

Mit einer Schleife über ein Array laufen

fn main() {
    let numbers = [10, 20, 30];

    for n in numbers {
        println!("{n}");
    }
}

▶ Selbst ausprobieren

Arrays aus Arrays (2D-Arrays)

Ein Array kann andere Arrays enthalten. So entsteht ein Raster aus Zeilen und Spalten – wie ein Spielbrett oder eine kleine Tabelle. Der Typ von grid unten ist [[i32; 3]; 2]. Du liest ihn als „2 Zeilen, jede ein Array aus 3 i32-Werten“.

fn main() {
    // 2 Zeilen, 3 Spalten
    let grid = [
        [1, 2, 3],
        [4, 5, 6],
    ];

    println!("Zeile 1, Spalte 2: {}", grid[1][2]);

    let mut total = 0;
    for row in grid {
        println!("{:?}", row);
        for value in row {
            total += value;
        }
    }
    println!("Summe: {total}");
}

Ausgabe:

Zeile 1, Spalte 2: 6
[1, 2, 3]
[4, 5, 6]
Summe: 21

▶ Selbst ausprobieren

grid[1][2] heißt „Zeile 1, und darin Spalte 2“. Beide Zählungen beginnen bei 0, das ist also die zweite Zeile, dritter Wert. Um jeden Wert zu besuchen, nimmst du eine Schleife für die Zeilen und darin eine zweite Schleife für die Werte jeder Zeile.

Jede Zeile muss gleich lang sein, denn die Zeilenlänge gehört zum Typ. Brauchst du beim Durchlaufen auch die jeweilige Position, liefert dir .iter().enumerate() Index und Wert zusammen. Das zeigt dir die Seite for-Schleife.

Arrays oder Vektoren?

Nimm ein Array, wenn die Größe fest ist und von Anfang an feststeht (etwa die sieben Wochentage). Nimm einen Vec, wenn du Elemente hinzufügen oder entfernen musst – und das ist in der Praxis meistens der Fall. Im Rust-Alltag begegnen dir Arrays seltener als Vektoren.

Übungen

1. Summe und Durchschnitt

Leg das Array [4, 8, 15, 16, 23, 42] an. Addiere alle Werte und gib dann die Summe und den Durchschnitt mit zwei Nachkommastellen aus. Tipp: Lauf mit for durch, halte eine laufende Summe total und mach aus beiden Zahlen mit as ein f64, bevor du teilst.

Lösung anzeigen

fn main() {
    let numbers = [4, 8, 15, 16, 23, 42];

    let mut total = 0;
    for n in numbers {
        total += n;
    }

    let average = total as f64 / numbers.len() as f64;
    println!("Summe: {total}");
    println!("Durchschnitt: {average:.2}");
}

Ausgabe:

Summe: 108
Durchschnitt: 18.00

▶ Selbst ausprobieren

Ohne as f64 wäre total / numbers.len() eine Ganzzahldivision. Außerdem würde Rust sich beschweren, dass total (ein i32) und len() (ein usize) verschiedene Typen sind.

2. Der heißeste Tag

Du hast die Temperaturen einer Woche: [18, 25, 12, 31, 22, 27, 19]. Finde die höchste und gib sie aus. Tipp: Beginne mit let mut hottest = temps[0];, lauf dann durch und ersetze den Wert jedes Mal, wenn du einen größeren findest.

Lösung anzeigen

fn main() {
    let temps = [18, 25, 12, 31, 22, 27, 19];

    let mut hottest = temps[0];
    for t in temps {
        if t > hottest {
            hottest = t;
        }
    }

    println!("Heißester Tag: {hottest}");
}

Ausgabe:

Heißester Tag: 31

▶ Selbst ausprobieren

Dass du bei temps[0] statt bei 0 anfängst, ist wichtig: Lägen alle Temperaturen unter null, käme mit dem Startwert 0 ein falsches Ergebnis heraus.

Zusammenfassung

• Arrays haben eine feste Länge, die zum Typ gehört: [i32; 5].
• Auf Elemente greifst du mit array[index] zu, beginnend bei 0.
• Ein Zugriff außerhalb der Grenzen löst zur Laufzeit eine Panic aus, statt undefiniertes Verhalten zu verursachen.
• Arrays können Arrays enthalten: [[i32; 3]; 2] ist ein Raster, das du mit grid[zeile][spalte] liest.
• Musst du die Größe ändern, nimm stattdessen einen Vec.

Kurzer Check

Kurzer Check

1. Was stimmt für die Länge eines Arrays in Rust?

Sie kann mit .push() wachsen Sie steht erst zur Laufzeit fest Sie gehört zum Typ des Arrays, z. B. [i32; 5]

2. Was passiert, wenn du zur Laufzeit auf einen Index außerhalb der Grenzen zugreifst?

Das Programm löst eine Panic aus Rust gibt einen Standardwert wie 0 zurück Es liest, was gerade im Speicher liegt – wie in C

3. Was erzeugt let zeros = [0; 5];?

Ein Array aus 5 verschiedenen Zufallszahlen Ein Array aus fünf Nullen Einen einzelnen Wert 0, der beim Ausgeben 5-mal wiederholt wird

Punkte: 0 / 3

Weiterlesen

• Der Array-Typ – Das Rust-Buch: die offizielle Einführung in Arrays, auch dazu, warum die Länge zum Typ gehört.
• Arrays and Slices – Rust by Example (auf Englisch): kurze, ausführbare Beispiele und ein erster Blick auf Slices.
• Durchlaufen einer Kollektion mit for – Das Rust-Buch: warum eine for-Schleife sicherer ist, als ein Array per Index abzulaufen.
• array – Doku der Standardbibliothek (auf Englisch): was Arrays können, etwa map und as_slice, und wie sie auch alle Methoden von Slices mitbenutzen.