Rust: Beispiele und Erklärung

1. 1 + 2 + 3 + 4 + 5 = 15

Die Zahlen 1 bis 5 werden zu 15 addiert. Der Rückgabewert 15 wird als Prozess-Exitcode geprüft.

fn main() -> i64 {
    let mut sum: i64 = 0;
    let mut i: i64 = 1;
    loop {
        sum = sum + i;
        if i >= 5 { break; }
        i = i + 1;
    }
    return sum;   // 15
}

Erwarteter Exitcode: 15

PBXB64.exe sum15-rust.rs -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Nativ geprüft mit dem V22-Kandidaten vom 30.09.2026; Prüfung mit dem finalen Compiler noch ausstehend.

2. Integerdivision und Rest

20 / 4 ist 5, 17 % 5 ist 2. main gibt ihre Summe 7 als i64 zurück. Hier sind alle Operanden ganze Zahlen.

fn main() -> i64 {
    return (20 / 4) + (17 % 5);
}

Erwarteter Exitcode: 7

PBXB64.exe test_rust_arith.rs -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Kanonischer Testfall mit erwartetem Ergebnis; hier keine neue native V22-Prüfung. Finale Ausführung noch ausstehend.

3. Zwei Werte in einem Tupel

p hat den Typ (i64, i64) und enthält 20 sowie 22. p.0 und p.1 greifen auf die beiden Felder zu; main liefert 42.

fn main() -> i64 {
    let p: (i64, i64) = (20, 22);
    return p.0 + p.1;
}

Erwarteter Exitcode: 42

PBXB64.exe test_rust_tuple.rs -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Kanonischer Testfall mit erwartetem Ergebnis; hier keine neue native V22-Prüfung. Finale Ausführung noch ausstehend.

4. Zwei typisierte lokale Werte

Ablauf Schritt für Schritt

1. let definiert x mit 10 und y mit 32, jeweils als i64.
2. Die beiden Werte werden in diesem Programm nicht verändert.
3. return x + y liefert 42 an den Prozess, ohne eine Konsolenausgabe zu erzeugen.

fn main() -> i64 {
    let x: i64 = 10;
    let y: i64 = 32;
    return x + y;
}

Erwarteter Exitcode: 42

PBXB64.exe rust-test_rust_vars.rs -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

5. Eine Funktion mit zwei Argumenten

Ablauf Schritt für Schritt

1. add deklariert zwei i64-Parameter und einen i64-Rückgabetyp.
2. main übergibt die Werte 10 und 32.
3. Der Rückgabewert der Addition wird direkt zum Rückgabewert von main.

fn add(a: i64, b: i64) -> i64 {
    return a + b;
}
fn main() -> i64 {
    return add(10, 32);
}

Erwarteter Exitcode: 42

PBXB64.exe rust-test_rust_fn.rs -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

6. Fakultät mit einer Abbruchbedingung

Ablauf Schritt für Schritt

1. Für n <= 1 liefert fact den Basiswert 1.
2. Andere Aufrufe multiplizieren n mit fact(n - 1).
3. fact(5) ergibt 5 × 4 × 3 × 2 × 1 = 120. Die kleine Eingabe bleibt innerhalb des i64-Bereichs.

fn fact(n: i64) -> i64 {
    if n <= 1 { return 1; }
    return n * fact(n - 1);
}
fn main() -> i64 {
    return fact(5);
}

Erwarteter Exitcode: 120

PBXB64.exe rust-test_rust_rec.rs -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

7. if/else mit zwei Rückgabewerten

Ablauf Schritt für Schritt

1. x enthält 5; x > 3 ist deshalb wahr.
2. Der erste Zweig liefert 1 und beendet main.
3. Die 1 ist in diesem Beispiel das erwartete Resultat, kein gemeldeter Testfehler.

fn main() -> i64 {
    let x: i64 = 5;
    if x > 3 {
        return 1;
    } else {
        return 0;
    }
}

Erwarteter Exitcode: 1

PBXB64.exe rust-test_rust_if.rs -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

8. loop mit einem expliziten break

Ablauf Schritt für Schritt

1. let mut erlaubt die Änderung des Zählers i.
2. Jeder Durchlauf erhöht i und prüft anschließend i >= 5.
3. break verlässt die Schleife bei 5; return gibt den erreichten Zählerstand weiter.

fn main() -> i64 {
    let mut i: i64 = 0;
    loop {
        i = i + 1;
        if i >= 5 { break; }
    }
    return i;
}

Erwarteter Exitcode: 5

PBXB64.exe rust-test_rust_loop.rs -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

9. while addiert die Zahlen 1 bis 5

Ablauf Schritt für Schritt

1. sum beginnt bei 0, i bei 1; beide Variablen sind veränderlich.
2. Die Bedingung i <= 5 schließt die 5 ein; der Rumpf addiert i und erhöht es.
3. Nach dem letzten Durchlauf ist i = 6 und sum = 15.

fn main() -> i64 {
    let mut sum: i64 = 0;
    let mut i: i64 = 1;
    while i <= 5 {
        sum = sum + i;
        i = i + 1;
    }
    return sum;
}

Erwarteter Exitcode: 15

PBXB64.exe rust-test_rust_while.rs -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

10. Offene und geschlossene Range-Grenzen

Ablauf Schritt für Schritt

1. 0..5 enthält 0, 1, 2, 3 und 4, deren Summe 10 ist.
2. 1..=3 schließt die Endgrenze ein und addiert 1 + 2 + 3 = 6.
3. Der gemeinsame Zähler total erreicht 16.

fn main() -> i64 {
    let mut total: i64 = 0;
    for i in 0..5 {
        total += i;
    }
    for j in 1..=3 {
        total += j;
    }
    return total;
}

Erwarteter Exitcode: 16

PBXB64.exe rust-test_rust_for_ranges.rs -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

11. Arrayelemente, Liste und Wiederholungsinitialisierung

Ablauf Schritt für Schritt

1. values erhält an den verwendeten Indizes 0 und 1 die Werte 10 und 20.
2. listed enthält 30 und 40; [5i64; 2] legt zwei Elemente mit dem Wert 5 an.
3. Die nicht initialisierten weiteren values-Elemente werden nicht gelesen. Die verwendeten Werte ergeben 110.

fn main() -> i64 {
    let mut values: [i64; 4];
    values[0] = 10;
    values[1] = 20;
    let listed = [30i64, 40i64];
    let repeated = [5i64; 2];
    return values[0] + values[1] + listed[0] + listed[1] + repeated[0] + repeated[1];
}

Erwarteter Exitcode: 110

PBXB64.exe rust-test_rust_arrays.rs -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

12. Eine Struktur mit benannten Feldern

Ablauf Schritt für Schritt

1. Point deklariert die Felder x und y als i64.
2. Beide Felder der lokalen Instanz p werden vor dem Lesen gesetzt.
3. p.x + p.y ist 20 + 22 = 42; dies ist ein Beispiel des PBXB64-Rust-Eingangs.

struct Point {
    x: i64,
    y: i64,
}

fn main() -> i64 {
    let p: Point;
    p.x = 20;
    p.y = 22;
    return p.x + p.y;
}

Erwarteter Exitcode: 42

PBXB64.exe rust-test_rust_named_struct.rs -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

Großes Beispiel: Funktion, Schleifen und match zusammen verwenden

Ablauf Schritt für Schritt

1. helper verändert den Parameter über mehrere Änderungsoperatoren; für 15 endet b nach %= 3 bei 0.
2. loop zählt i bis 3, while anschließend bis 5. Der match-Zweig für x = 15 kombiniert die vorbereiteten Zahlenwerte.
3. !15 ist beim i64-Wert -16, 15 << 1 ist 30 und 15 >> 1 ist 7. 0 - 5 - 16 + 30 + 7 + 5 ergibt den Exitcode 21.

// Rust-subset lexer/parser coverage fixture.
fn helper(a: i64) -> i64 {
    let mut b: i64 = a;
    b += 1;
    b -= 1;
    b *= 2;
    b /= 2;
    b %= 3;
    return b;
}

fn main() -> i64 {
    let mut x: i64 = 15;
    let neg: i64 = -5;
    let not_x: i64 = !x;
    let shl_v: i64 = x << 1;
    let shr_v: i64 = x >> 1;
    let mut i: i64 = 0;
    loop {
        if i >= 3 {
            break;
        }
        i += 1;
        continue;
    }
    while i < 5 {
        i += 1;
    }
    if x > 10 {
        match x {
            15 => { return helper(x) + neg + not_x + shl_v + shr_v + i; }
            _ => { return 0; }
        }
    }
    return 99;
}

Erwarteter Exitcode: 21

PBXB64.exe rust-test_rust_full.rs -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.