Les opérateurs en Rust

Les opérateurs sont les symboles qui servent à faire des calculs, à comparer des valeurs et à combiner des conditions. Si vous avez déjà utilisé un langage inspiré du C, la plupart vous sembleront familiers.

Opérateurs arithmétiques

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

    println!("{}", a + b); // 13
    println!("{}", a - b); // 7
    println!("{}", a * b); // 30
    println!("{}", a / b); // 3  (division entière, le reste est perdu)
    println!("{}", a % b); // 1  (le reste)
}

▶ Essayez par vous-même

Attention

a / b avec deux entiers donne une division entière : 10 / 3 vaut 3, et non 3.333.... Si vous voulez un résultat décimal, au moins un des deux côtés doit être un nombre à virgule : 10.0 / 3.0.

Opérateurs de comparaison

Ils comparent deux valeurs et renvoient un bool :

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
}

Vous les utiliserez sans arrêt dans les conditions des if, que nous verrons à la page If…Else en Rust.

Opérateurs logiques

Les opérateurs logiques combinent ou inversent des valeurs booléennes :

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

    println!("{}", is_logged_in && is_admin); // false : les deux doivent être vrais
    println!("{}", is_logged_in || is_admin); // true  : au moins un est vrai
    println!("{}", !is_admin);                // true  : transforme false en true
}

▶ Essayez par vous-même

• && : et (and), vrai seulement si les deux côtés sont vrais.
• || : ou (or), vrai si au moins un côté est vrai.
• ! : non (not), transforme vrai en faux et inversement.

Opérateurs d’affectation

En plus du simple =, Rust propose des opérateurs abrégés qui mettent à jour une variable à partir de sa valeur actuelle :

fn main() {
    let mut score = 10;

    score += 5; // équivaut à : score = score + 5
    score -= 2; // score = score - 2
    score *= 3; // score = score * 3
    score /= 2; // score = score / 2

    println!("{score}");
}

▶ Essayez par vous-même

N’oubliez pas que la variable doit être déclarée avec mut pour que ces lignes compilent : vous modifiez sa valeur.

Note

Rust n’a pas d’opérateurs ++ ni --. Pour ajouter un à un compteur, écrivez count += 1. C’est un caractère de plus, et il n’y a aucun doute sur ce qui se passe.

Ordre des opérations (priorité)

Quand une expression contient plusieurs opérateurs, Rust ne va pas simplement de gauche à droite. Comme en maths à l’école, *, / et % passent avant + et -. Les opérateurs de même niveau s’exécutent de gauche à droite. Les parenthèses passent toujours en premier : utilisez-les dès que vous voulez un autre ordre.

fn main() {
    let a = 2 + 3 * 4;            // * d'abord : 2 + 12
    let b = (2 + 3) * 4;          // parenthèses d'abord : 5 * 4
    let c = 10 - 4 - 3;           // même niveau, de gauche à droite : (10 - 4) - 3
    let d = 17 % 5 * 2;           // même niveau, de gauche à droite : (17 % 5) * 2
    let ok = 1 + 1 == 2 && 3 > 2; // calculs, puis comparaisons, puis &&

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

Sortie :

14 20 3 4 true

▶ Essayez par vous-même

L’ordre complet, du premier au dernier, est à peu près le suivant : l’arithmétique (* / %, puis + -), puis les comparaisons (== != < > <= >=), puis &&, puis ||, et enfin les opérateurs d’affectation (= += -= et compagnie). C’est pour cela que 1 + 1 == 2 && 3 > 2 fonctionne sans aucune parenthèse. Cela dit, si vous devez vous arrêter pour réfléchir à l’ordre, ajoutez des parenthèses. Elles ne coûtent rien et rendent le code plus facile à lire.

Attention

Vous ne pouvez pas enchaîner les comparaisons comme en maths. 1 < x < 5 provoque une erreur de compilation (« comparison operators cannot be chained », c’est-à-dire « les opérateurs de comparaison ne peuvent pas être enchaînés »). Écrivez plutôt deux comparaisons reliées par && : 1 < x && x < 5.

Exercices

1. Minutes et secondes

Une vidéo dure 125 secondes. Stockez cette valeur dans une variable, puis affichez combien cela fait de minutes entières et de secondes restantes, par exemple 2 minutes et 5 secondes. Indice : la division entière / donne les minutes entières, et % donne ce qui reste.

Voir la solution

fn main() {
    let total_seconds = 125;

    let minutes = total_seconds / 60; // 2 (le reste est perdu)
    let seconds = total_seconds % 60; // 5 (le reste)

    println!("{minutes} minutes et {seconds} secondes");
}

Sortie :

2 minutes et 5 secondes

▶ Essayez par vous-même

2. Compter les points

Démarrez le score d’une partie à 10. Ajoutez 25, retirez 5, puis doublez-le, avec les opérateurs d’affectation abrégés. Affichez le score, s’il vaut au moins 50, et s’il vaut au moins 50 et est pair. Indice : un nombre est pair quand score % 2 == 0.

Voir la solution

fn main() {
    let mut score = 10;

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

    println!("score : {score}");
    println!("niveau réussi ? {}", score >= 50);
    println!("réussi et pair ? {}", score >= 50 && score % 2 == 0);
}

Sortie :

score : 60
niveau réussi ? true
réussi et pair ? true

▶ Essayez par vous-même

Récapitulatif

• Arithmétique : + - * / %. La division entière tronque le résultat : pas de décimales.
• Comparaison : == != < > <= >=, qui renvoient tous un bool.
• Logique : && (et), || (ou), ! (non).
• Affectation abrégée : += -= *= /= modifient sur place une variable mut. Il n’y a pas de ++.
• * / % passent avant + -, et les calculs passent avant les comparaisons et &&/||. En cas de doute, mettez des parenthèses.

Petit quiz

Petit quiz

1. Que vaut 10 / 3 quand les deux côtés sont des entiers ?

3.333... 3 4

2. Quel type renvoient toujours les opérateurs de comparaison comme == et < ?

i32 String bool

3. Que faut-il pour que score += 5; compile ?

score doit être déclaré avec mut score doit être un f64 Rien de spécial : cela compile toujours

Score : 0 / 3

Pour aller plus loin

• B - Operators and Symbols — The Rust Book (en anglais) : un tableau d’une page avec tous les opérateurs de Rust et leur rôle.
• Literals and operators — Rust by Example (en anglais) : de courts exemples exécutables d’opérateurs arithmétiques, logiques et bit à bit.
• Expression precedence — The Rust Reference (en anglais) : l’ordre exact dans lequel Rust évalue les opérateurs, du premier au dernier.
• Operator expressions — The Rust Reference (en anglais) : les règles précises de chaque opérateur, y compris ce qui se passe en cas de dépassement d’entier.