Operatoren in Rust

Operatoren sind die Symbole, mit denen du rechnest, Werte vergleichst und Bedingungen verknüpfst. Wenn du schon mal eine Sprache wie C, Java oder JavaScript benutzt hast, kommen dir die meisten bekannt vor.

Arithmetische Operatoren

fn main() {
    let a = 10;
    let b = 3;

    println!("{}", a + b); // 13
    println!("{}", a - b); // 7
    println!("{}", a * b); // 30
    println!("{}", a / b); // 3  (Ganzzahldivision, der Rest fällt weg)
    println!("{}", a % b); // 1  (Rest)
}

▶ Selbst ausprobieren

Achtung

a / b mit zwei Ganzzahlen ergibt eine Ganzzahldivision: 10 / 3 ist 3, nicht 3.333.... Wenn du ein Ergebnis mit Nachkommastellen willst, muss mindestens eine Seite eine Gleitkommazahl sein: 10.0 / 3.0.

Vergleichsoperatoren

Sie vergleichen zwei Werte und liefern ein bool zurück:

fn main() {
    let a = 5;
    let b = 8;

    println!("{}", a == b); // false
    println!("{}", a != b); // true
    println!("{}", a < b);  // true
    println!("{}", a > b);  // false
    println!("{}", a <= b); // true
    println!("{}", a >= b); // false
}

Du wirst sie ständig in if-Bedingungen verwenden. Die behandeln wir auf der Seite If…Else.

Logische Operatoren

Logische Operatoren verknüpfen Boolean-Werte oder kehren sie um:

fn main() {
    let is_logged_in = true;
    let is_admin = false;

    println!("{}", is_logged_in && is_admin); // false – beide müssen true sein
    println!("{}", is_logged_in || is_admin); // true  – mindestens einer ist true
    println!("{}", !is_admin);                // true  – dreht false zu true um
}

▶ Selbst ausprobieren

• && – und: nur true, wenn beide Seiten true sind.
• || – oder: true, wenn mindestens eine Seite true ist.
• ! – nicht: macht aus true false und umgekehrt.

Zuweisungsoperatoren

Neben dem einfachen = hat Rust Kurzschreibweisen, die eine Variable anhand ihres aktuellen Werts ändern:

fn main() {
    let mut score = 10;

    score += 5; // dasselbe wie: score = score + 5
    score -= 2; // score = score - 2
    score *= 3; // score = score * 3
    score /= 2; // score = score / 2

    println!("{score}");
}

▶ Selbst ausprobieren

Denk daran: Damit das kompiliert, braucht die Variable mut – schließlich änderst du ihren Wert.

Hinweis

Rust hat keine Operatoren ++ oder --. Um einen Zähler um eins zu erhöhen, schreibst du count += 1. Das ist ein Zeichen mehr – und es lässt keinen Zweifel, was passiert.

Rangfolge der Operatoren (Präzedenz)

Wenn ein Ausdruck mehrere Operatoren enthält, rechnet Rust nicht einfach von links nach rechts. Wie in der Schule gilt „Punkt vor Strich“: *, / und % kommen vor + und -. Operatoren auf derselben Stufe werden von links nach rechts ausgewertet. Klammern kommen immer zuerst – setz sie also, wann immer du eine andere Reihenfolge willst.

fn main() {
    let a = 2 + 3 * 4;            // * zuerst: 2 + 12
    let b = (2 + 3) * 4;          // Klammern zuerst: 5 * 4
    let c = 10 - 4 - 3;           // gleiche Stufe, von links nach rechts: (10 - 4) - 3
    let d = 17 % 5 * 2;           // gleiche Stufe, von links nach rechts: (17 % 5) * 2
    let ok = 1 + 1 == 2 && 3 > 2; // erst Rechnen, dann Vergleiche, dann &&

    println!("{a} {b} {c} {d} {ok}");
}

Ausgabe:

14 20 3 4 true

▶ Selbst ausprobieren

Die vollständige Reihenfolge, von zuerst bis zuletzt, ist ungefähr: Arithmetik (* / %, dann + -), dann Vergleiche (== != < > <= >=), dann &&, dann || und ganz am Ende die Zuweisungsoperatoren (= += -= und Co.). Deshalb funktioniert 1 + 1 == 2 && 3 > 2 ganz ohne Klammern. Trotzdem gilt: Wenn du über die Reihenfolge erst nachdenken musst, setz Klammern. Sie kosten nichts und machen den Code leichter lesbar.

Achtung

Vergleiche lassen sich nicht wie in der Mathematik verketten. 1 < x < 5 ist ein Compiler-Fehler („comparison operators cannot be chained“, also: Vergleichsoperatoren können nicht verkettet werden). Schreib stattdessen zwei Vergleiche, verbunden mit &&: 1 < x && x < 5.

Übungen

1. Minuten und Sekunden

Ein Video ist 125 Sekunden lang. Speichere das in einer Variable und gib dann aus, wie viele volle Minuten und übrige Sekunden das sind, etwa 2 Minuten und 5 Sekunden. Tipp: Die Ganzzahldivision / liefert die vollen Minuten, % liefert den Rest.

Lösung anzeigen

fn main() {
    let total_seconds = 125;

    let minutes = total_seconds / 60; // 2 (der Rest fällt weg)
    let seconds = total_seconds % 60; // 5 (der Rest)

    println!("{minutes} Minuten und {seconds} Sekunden");
}

Ausgabe:

2 Minuten und 5 Sekunden

▶ Selbst ausprobieren

2. Punkte zählen

Lass den Punktestand score eines Spiels bei 10 starten. Addiere 25, zieh 5 ab und verdopple ihn dann – jeweils mit den Kurzschreibweisen für Zuweisungen. Gib den Punktestand aus, ob er mindestens 50 beträgt, und ob er mindestens 50 und gerade ist. Tipp: Eine Zahl ist gerade, wenn score % 2 == 0 gilt.

Lösung anzeigen

fn main() {
    let mut score = 10;

    score += 25; // 35
    score -= 5;  // 30
    score *= 2;  // 60

    println!("Punkte: {score}");
    println!("Level geschafft? {}", score >= 50);
    println!("Geschafft und gerade? {}", score >= 50 && score % 2 == 0);
}

Ausgabe:

Punkte: 60
Level geschafft? true
Geschafft und gerade? true

▶ Selbst ausprobieren

Zusammenfassung

• Arithmetik: + - * / %. Ganzzahldivision schneidet ab – keine Nachkommastellen.
• Vergleich: == != < > <= >=, alle liefern ein bool.
• Logik: && (und), || (oder), ! (nicht).
• Kurzschreibweisen: += -= *= /= ändern eine mut-Variable direkt. Ein ++ gibt es nicht.
• * / % kommen vor + -, und Rechnen kommt vor Vergleichen und &&/||. Im Zweifel setz Klammern.

Kurzer Check

Kurzer Check

1. Was ergibt 10 / 3, wenn beide Seiten Ganzzahlen sind?

3.333... 3 4

2. Welchen Typ liefern Vergleichsoperatoren wie == und < immer zurück?

i32 String bool

3. Was ist nötig, damit score += 5; kompiliert?

score muss mit mut deklariert sein score muss ein f64 sein Nichts Besonderes – es kompiliert immer

Punkte: 0 / 3

Weiterlesen

• B – Operatoren und Symbole – Die Programmiersprache Rust: eine Tabelle mit allen Operatoren in Rust und was sie tun, auf einer Seite.
• Literals and operators – Rust by Example (auf Englisch): kurze, lauffähige Beispiele für arithmetische, logische und bitweise Operatoren.
• Expression precedence – The Rust Reference (auf Englisch): die genaue Reihenfolge, in der Rust Operatoren auswertet, von zuerst bis zuletzt.
• Operator expressions – The Rust Reference (auf Englisch): die genauen Regeln für jeden Operator, auch was bei einem Ganzzahlüberlauf passiert.