Literale und Operatoren - Rust Tutorial

Literal: Festwertdaten, die direkt im Code geschrieben sind und deren Wert man sofort erkennt. Es ist die grundlegendste Form der Datendarstellung in einem Programm.

Der Wert ist fest und unveränderlich, fest im Code hinterlegt und kann während der Laufzeit nicht verändert werden. Es sind keine Berechnungen oder Variablenauswertungen nötig, wörtlich bedeutet es „Wortgetreuer Wert“.

Beispiel: Die unten stehenden 13 und 3.14 sind Literale, in anderen Sprachen spricht man auch von Wertliteralen.

fn main() {
    println!("{}", 13);
    println!("{}", 3.14);
}Code-Sprache: JavaScript (javascript)

Zum einfachen Lernen stellt das offizielle Team einen Online-Rust-Editor zur Verfügung. Ohne lokale Umgebung installieren zu müssen, können Sie alle grundlegenden Rust-Syntaxen üben. Klicken Sie auf den folgenden Link

Rust Playground

Literale

Rust unterstützt Literale folgender Typen: Ganzzahl, Gleitkommazahl, Zeichen, Zeichenkette, Boolean, Unit-Typ.

Ganzzahl: 11
Zeichen: 'a' (einfache Anführungszeichen)
Zeichenkette: "abc" (doppelte Anführungszeichen)
Boolean: true / false
Unit-Typ: ()

Zahlsysteme für Ganzzahlen

Unterschieden werden die Zahlsysteme durch ein Präfix, das nur bei Ganzzahlen verwendet wird:

Hexadezimal: Beginnt mit 0x, Beispiel: 0x1F
Oktal: Beginnt mit 0o, Beispiel: 0o77
Binär: Beginnt mit 0b, Beispiel: 0b1010

Zahlen-Trennstrich

In Zahlenliteralen kann ein Unterstrich _ eingefügt werden, um die Lesbarkeit zu verbessern. Er beeinflusst den tatsächlichen Zahlenwert nicht:

Ganzzahl: 1_000 = 1000
Gleitkommazahl: 0.000_001 = 0.000001

Wissenschaftliche Notation

Gleitkommazahlen unterstützen die wissenschaftliche Schreibweise mit E, der Standardtyp ist f64:

1e6 = 1000000
7.6e-4 = 0.00076

Typ-Suffixe bei Literalen (Wichtig)

In Rust muss der Typ eines Literals explizit angegeben werden. Hier sind die gängigsten Suffixe:

u32: 32-Bit-vorzeichenlose Ganzzahl (nur nicht-negative Werte)
i32: 32-Bit-vorzeichenbehaftete Ganzzahl (positive und negative Werte erlaubt)

Hinweis: Sie können vorzeichenbehaftete und vorzeichenlose Ganzzahlen nicht gemeinsam berechnen, dies führt direkt zu einem Fehler.

Beispielcode:

fn main() {
    // 1. Einfaches Ganzzahlliteral
    println!("Ganzzahl: {}", 13);
    // Binäre, oktale, hexadezimale Ganzzahlen
    println!("Binär: {}", 0b1010);
    println!("Oktal: {}", 0o77);
    println!("Hexadezimal: {}", 0x2A);
    // Ganzzahl mit Trennstrich (bessere Lesbarkeit)
    println!("Ganzzahl mit Unterstrich: {}", 1_000_000);
    // Ganzzahl mit Typ-Suffix
    println!("u32 vorzeichenlose Ganzzahl: {}", 100u32);
    println!("i32 vorzeichenbehaftete Ganzzahl: {}", -50i32);

    // 2. Gleitkommazahlliteral
    println!("Gleitkommazahl: {}", 3.14);
    // Gleitkommazahl mit Unterstrich
    println!("Gleitkommazahl mit Unterstrich: {}", 0.000_001);
    // Gleitkommazahl mit wissenschaftlicher Notation
    println!("Wissenschaftliche Notation: {}", 1e6);
    println!("Negative wissenschaftliche Notation: {}", 7.6e-4);

    // 3. Zeichenkettenliteral (doppelte Anführungszeichen)
    println!("Zeichenkette: {}", "hello world");

    // 4. Zeichenliteral (einfache Anführungszeichen, nur ein einzelnes Zeichen)
    println!("Zeichen: {}", 'a');
    println!("Chinesisches Zeichen: {}", '中');

    // 5. Boolean-Literal
    println!("Boolean true: {}", true);
    println!("Boolean false: {}", false);

    // 6. Unit-Literal () (Rust Unit-Typ)
    println!("Unit-Typ: {:?}", ());
}Code-Sprache: JavaScript (javascript)

Operatoren

Regeln und Prioritäten der Rust-Operatoren stimmen weitgehend mit C-ähnlichen Sprachen überein.

1. Arithmetische Operatoren

Grundrechenarten wie Addition und Subtraktion, verwenden Sie diese mit den Typ-Suffixen von Ganzzahlen:

Addition: +
Subtraktion: -

2. Boolesche Logikoperatoren (Kurzschlusslogik)

Funktionieren nur mit booleschen Werten true/false:

Und &&: Ergebnis nur true, wenn beide Seiten true sind
Oder ||: Ergebnis true, wenn mindestens eine Seite true ist
Nicht !: Kehrt den booleschen Wert um

Ausdruck	Ergebnis der Berechnung
true && true	true
true && false	false
false && true	false
false && false	false
true \|\| true	true
true \|\| false	true
false \|\| true	true
false \|\| false	false
!true	false
!false	true

3. Bitoperatoren (Binärbit-Verarbeitung)

Hauptsächlich für Ganzzahlen verwendet, das Beispiel nutzt {:04b} zur formatierten Ausgabe einer 4-stelligen Binärzahl:

Bitweises UND &: Ergebnisbit ist 1, wenn beide Bits an gleicher Stelle 1 sind
Bitweises ODER |: Ergebnisbit ist 1, wenn mindestens ein Bit an gleicher Stelle 1 ist
Bitweises XOR ^: Ergebnisbit ist 1, wenn die Bits an gleicher Stelle unterschiedlich sind, sonst 0
Linksverschiebung <<: Alle Binärbits nach links schieben (entspricht ×2ⁿ)
Rechtsverschiebung >>: Alle Binärbits nach rechts schieben (entspricht ÷2ⁿ)

  0 0 1 1
& 0 1 0 1
-----------
  0 0 0 1  

  0 0 1 1
| 0 1 0 1
-----------
  0 1 1 1

  0 0 1 1
^ 0 1 0 1
-----------
  0 1 1 0

Linksverschiebung <<
Binär: 00000001
5 Stellen nach links geschoben → 00100000, Ergebnis = 32

Rechtsverschiebung >>
0x80 Binär: 10000000
2 Stellen nach rechts geschoben → 00100000 (Hexadezimal 0x20), Ergebnis = 32

fn main() {
    // ========== Arithmetische Operatoren ==========
    // Ganzzahladdition: u32 32-Bit vorzeichenlose Ganzzahl
    // Ergebnis: 1 + 2 = 3
    println!("1 + 2 = {}", 1u32 + 2);

    // Ganzzahlen-Subtraktion: i32 32-Bit vorzeichenbehaftete Ganzzahl, unterstützt Negative
    // Bei Ersetzung mit 1u32 entsteht ein Fehler, vorzeichenlose Zahlen können keine Negativen darstellen
    // Ergebnis: 1 - 2 = -1
    println!("1 - 2 = {}", 1i32 - 2);

    // ========== Gleitkommazahlen-Literale - Wissenschaftliche Notation ==========
    // Ergebnis: 1e4 ergibt 10000, -2.5e-3 ergibt -0.0025
    println!("1e4 ist {}, -2.5e-3 ist {}", 1e4, -2.5e-3);

    // ========== Boolesche Logikoperatoren (Kurzschlussberechnung) ==========
    // Logisches UND &&: Ergebnis true nur wenn beide Seiten true sind
    // Ergebnis: true UND false = false
    println!("true UND false = {}", true && false);

    // Logisches ODER ||: Ergebnis true wenn eine Seite true ist
    // Ergebnis: true ODER false = true
    println!("true ODER false = {}", true || false);

    // Logisches NICHT !: Kehrt den booleschen Wert um
    // Ergebnis: NICHT true = false
    println!("NICHT true = {}", !true);

    // ========== Bitoperatoren (Binärbit-Verarbeitung) ==========
    // {:04b} Gibt stets 4 Binärstellen aus, fehlende Stellen links mit 0 auffüllen
    // Bitweises UND &: Ergebnisbit 1 nur wenn beide korrespondierenden Bits 1 sind
    // Ergebnis: 0011 bitweises UND 0101 = 0001
    println!("0011 bitweises UND 0101 = {:04b}", 0b0011u32 & 0b0101);

    // Bitweises ODER |: Ergebnisbit 1 wenn ein korrespondierendes Bit 1 ist
    // Ergebnis: 0011 bitweises ODER 0101 = 0111
    println!("0011 bitweises ODER 0101 = {:04b}", 0b0011u32 | 0b0101);

    // Bitweises XOR ^: Ergebnisbit 1 bei unterschiedlichen korrespondierenden Bits
    // Ergebnis: 0011 bitweises XOR 0101 = 0110
    println!("0011 bitweises XOR 0101 = {:04b}", 0b0011u32 ^ 0b0101);

    // Linksverschiebung <<: Alle Binärbits um 5 Stellen nach links
    // Ergebnis: 1 um 5 Stellen nach links geschoben = 32
    println!("1 um 5 Stellen nach links geschoben = {}", 1u32 << 5);

    // Rechtsverschiebung >>: Alle Binärbits um 2 Stellen nach rechts, {:x} Hexadezimalausgabe
    // Ergebnis: 0x80 um 2 Stellen nach rechts geschoben = 0x20
    println!("0x80 um 2 Stellen nach rechts geschoben = 0x{:x}", 0x80u32 >> 2);

    // ========== Zahlen-Trennstrich _ ==========
    // Der Unterstrich dient nur der Lesbarkeit, verändert den Zahlenwert nicht
    // Ergebnis: Eine Million schreibt sich: 1000000
    println!("Eine Million schreibt sich: {}", 1_000_000u32);
}Code-Sprache: JavaScript (javascript)

III. Ergänzende Hinweise zur Code-Ausführung

Ersetzen Sie 1i32 durch 1u32 und führen Sie die Subtraktion 1u32 - 2 aus, erhalten Sie einen Fehler: Vorzeichenlose Ganzzahlen können keine negativen Werte darstellen.
{:04b}: Formatierungssyntax, b steht für Binär, 04 füllt fehlende Stellen links mit Null auf, falls weniger als 4 Bits vorhanden sind.
Bei großen Zahlen empfehlt sich der Unterstrich als Trennzeichen (z.B. 1_000_000u32), das verbessert die Lesbarkeit des Codes deutlich.

Previous: Grundtypen

Next: Tupel