Rust-Operatoren

In Rust spielen Operatoren eine zentrale Rolle, egal ob es sich um einfache numerische Berechnungen, logische Entscheidungen oder komplexere Pattern-Matching- und Bitoperationen handelt.

Rust unterstützt sowohl die aus der C-Familie bekannten gängigen Operatoren als auch einige einzigartige Operatorsymbole. Wer diese Operatoren beherrscht, macht den Code nicht nur prägnanter und effizienter, sondern versteht auch die Semantik von Rust besser.

1. Arithmetische Operatoren

Operator Beschreibung Beispiel Ergebnis
+ Addition 5 + 2 7
- Subtraktion 5 - 2 3
* Multiplikation 5 * 2 10
/ Division (ganzzahlige Division) 5 / 2 2(Ganzzahl)
% Rest 5 % 2 1

Beispiel

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

    println!("a + b = {}", a + b);
    println!("a - b = {}", a - b);
    println!("a * b = {}", a * b);
    println!("a / b = {}", a / b);
    println!("a % b = {}", a % b);
}

Ausgabe:

a + b = 13
a - b = 7
a * b = 30
a / b = 3
a % b = 1

Rust hat weder**noch^einen solchen Potenzierungsoperator (Hinweis:^ist bitweises XOR). Um eine Potenzierung durchzuführen, müssen Sie die integrierten Methoden pow oder powf verwenden:

  • Ganzzahltypenverwenden.pow(exp: u32)
  • Gleitkommatypenverwenden.powf(exp: f64)

Ganzzahlige Potenzierung

Beispiel

fn main() {
    let base: i32 = 2;
    let result = base.pow(3); // 2^3

    println!("2^3 = {}", result);
}

Ausgabe:

2^3 = 8

Gleitkomma-Potenzierung

Beispiel

fn main() {
    let base: f64 = 2.0;
    let result = base.powf(2.5); // 2^2.5

    println!("2^2.5 = {}", result);
}

Ausgabe:

2^2.5 = 5.656854249492381

2. Relationale (Vergleichs-)Operatoren

Operator Beschreibung Beispiel Ergebnis
== Equal 5 == 5 true
!= Nicht gleich 5 != 2 true
> Größer als 5 > 2 true
< Kleiner als 5 < 2 false
>= Größer als oder gleich 5 >= 5 true
<= Kleiner als oder gleich 2 <= 5 true

Beispiel

fn main() {
    let x = 5;
    let y = 10;

    println!("x == y : {}", x == y);
    println!("x != y : {}", x != y);
    println!("x > y  : {}", x > y);
    println!("x < y  : {}", x < y);
    println!("x >= y : {}", x >= y);
    println!("x <= y : {}", x <= y);
}

Ausgabe:

x == y : false
x != y : true
x > y  : false
x < y  : true
x >= y : false
x <= y : true

3. Logische Operatoren

Operator Beschreibung Beispiel Ergebnis
&& Logisches AND true && false false
|| Logisches OR true || false true
! Logisches NICHT !true false

Beispiel

fn main() {
    let a = true;
    let b = false;

    println!("a && b = {}", a && b);
    println!("a || b = {}", a || b);
    println!("!a = {}", !a);
}

Ausgabe:

a && b = false
a || b = true
!a = false

4. Bitweise Operatoren

Operator Beschreibung Beispiel Ergebnis
& Bitweises AND 5 & 3 1
| Bitweises OR 5 | 3 7
^ Bitweises XOR 5 ^ 3 6
! Bitweises NICHT !5 -6
<< Linksverschiebung 5 << 1 10
>> Rechtsverschiebung 5 >> 1 2

Beispiel

fn main() {
    let x: u8 = 0b1010; // 10
    let y: u8 = 0b1100; // 12

    println!("x & y = {:b}", x & y);
    println!("x | y = {:b}", x | y);
    println!("x ^ y = {:b}", x ^ y);
    println!("!x = {:b}", !x);
    println!("x << 1 = {:b}", x << 1);
    println!("x >> 1 = {:b}", x >> 1);
}

Ausgabe:

x & y = 1000
x | y = 1110
x ^ y = 110
!x = 11110101
x << 1 = 10100
x >> 1 = 101

5. Zuweisungs- und zusammengesetzte Zuweisungsoperatoren

Operator Beschreibung Beispiel Ergebnis
= Zuweisung let mut x = 5; x = 3; x = 3
+= Addieren und zuweisen x += 2 x = x + 2
-= Subtrahieren und zuweisen x -= 2 x = x - 2
*= Multiplizieren und zuweisen x *= 2 x = x * 2
/= Dividieren und zuweisen x /= 2 x = x / 2
%= Rest und Zuweisung x %= 2 x = x % 2
&= |= ^= <<= >>= Bitweise zusammengesetzte Zuweisung x &= 2 ähnlich

Beispiel

fn main() {
    let mut n = 5;

    n += 3;
    println!("n += 3 -> {}", n);

    n *= 2;
    println!("n *= 2 -> {}", n);

    n >>= 1;
    println!("n >>= 1 -> {}", n);
}

Ausgabe:

n += 3 -> 8
n *= 2 -> 16
n >>= 1 -> 8

6. Weitere gängige Operatoren

Operator Beschreibung Beispiel
.. Range (ohne rechten Endpunkt) 0..5erzeugt 0 bis 4
..= Bereich (einschließlich des rechten Endpunkts) 0..=5erzeugt 0 bis 5
as Typumwandlung 5 as f32
? Fehlerfortpflanzung (inResult) some()?;
* Dereferenzierung *ptr
& Referenz nehmen &x
ref Als Referenz binden let ref y = x;

Beispiel

fn main() {
    let x = 5;
    let y = x as f64;

    for i in 1..4 {
        print!("{} ", i);
    }
    println!();

    for i in 1..=3 {
        print!("{} ", i);
    }
    println!();

    let a = 10;
    let b = &a;
    println!("*b = {}", *b);
}

Ausgabe:

1 2 3 
1 2 3 
*b = 10
Andere Erweiterungen