Opérateurs Rust

En Rust, qu'il s'agisse de simples calculs numériques, de jugements logiques, ou de correspondances de motifs et d'opérations bit à bit plus complexes, les opérateurs jouent un rôle central.

Rust prend en charge à la fois les opérateurs courants familiers des langages de la famille C et fournit certains symboles d'opérateurs uniques. Maîtriser ces opérateurs permet non seulement de rendre le code plus concis et efficace, mais aussi de mieux comprendre la sémantique de Rust.

1. Opérateurs arithmétiques

Operator Description Exemple Résultat
+ Addition 5 + 2 7
- Soustraction 5 - 2 3
* Multiplication 5 * 2 10
/ Division (division entière) 5 / 2 2(entier)
% Reste 5 % 2 1

Exemple

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);
}

Sortie :

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

Rust n'a pas d'opérateur d'exponentiation tel que**ou^(note :^est un OU exclusif bit à bit). Pour effectuer une exponentiation, vous devez utiliser les méthodes intégrées pow ou powf :

  • Les types entiersutilisent.pow(exp: u32)
  • Les types à virgule flottanteutilisent.powf(exp: f64)

Exponentiation entière

Exemple

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

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

Sortie :

2^3 = 8

Exponentiation en virgule flottante

Exemple

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

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

Sortie :

2^2.5 = 5.656854249492381

2. Opérateurs relationnels (de comparaison)

Operator Description Exemple Résultat
== Equal 5 == 5 true
!= Différent de 5 != 2 true
> Supérieur à 5 > 2 true
< Inférieur à 5 < 2 false
>= Supérieur ou égal à 5 >= 5 true
<= Inférieur ou égal à 2 <= 5 true

Exemple

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);
}

Sortie :

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

3. Opérateurs logiques

Operator Description Exemple Résultat
&& ET logique true && false false
|| OU logique true || false true
! NON logique !true false

Exemple

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

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

Sortie :

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

4. Opérateurs bit à bit

Operator Description Exemple Résultat
& ET bit à bit 5 & 3 1
| OU bit à bit 5 | 3 7
^ OU exclusif bit à bit 5 ^ 3 6
! NON bit à bit !5 -6
<< Décalage à gauche 5 << 1 10
>> Décalage à droite 5 >> 1 2

Exemple

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);
}

Sortie :

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

5. Opérateurs d'affectation et d'affectation composée

Operator Description Exemple Résultat
= Affectation let mut x = 5; x = 3; x = 3
+= Addition et affectation x += 2 x = x + 2
-= Soustraction et affectation x -= 2 x = x - 2
*= Multiplication et affectation x *= 2 x = x * 2
/= Division et affectation x /= 2 x = x / 2
%= Reste et affectation x %= 2 x = x % 2
&= |= ^= <<= >>= Affectation composée bit à bit x &= 2 similaire

Exemple

fn main() {
    let mut n = 5;

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

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

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

Sortie :

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

6. Autres opérateurs courants

Operator Description Exemple
.. Intervalle (borne droite exclue) 0..5produit de 0 à 4
..= Intervalle (extrémité droite incluse) 0..=5produit de 0 à 5
as Conversion de type 5 as f32
? Propagation des erreurs (enResult) some()?;
* Déréférencement *ptr
& Prendre une référence &x
ref Lier en tant que référence let ref y = x;

Exemple

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);
}

Sortie :

1 2 3 
1 2 3 
*b = 10
Autres extensions