Opérateur modulo

Fait partie de la section Fundamentals du Journey Rust de Coddy — leçon 16 sur 75.

L'opérateur modulo % donne le reste d'une division. En Rust, il est utilisé avec une syntaxe simple :

let result = dividend % divisor;

dividend: Le nombre à diviser.
divisor: Le nombre qui divise le dividende.
result: Le reste de la division.

Par exemple :

let result = 10 % 3;

Ici, 10 est divisé par 3. 3 va dans 10 trois fois, avec un reste de 1. Ainsi, result sera 1.

Généralement, le modulo est utilisé pour vérifier si un nombre est pair ou impair :

Si un nombre est pair, le diviser par 2 laissera un reste de 0.
Si un nombre est impair, le diviser par 2 laissera un reste de 1.

Lors de l'utilisation du modulo avec des nombres à virgule flottante (f64), cela fonctionne de manière similaire aux entiers mais conserve la précision décimale. Par exemple :

let result: f64 = 5.2 % 2.0;
// le résultat est 1.2

Voici comment cela fonctionne : 2.0 va dans 5.2 deux fois (4.0), et le reste est 1.2 (5.2 - 4.0 = 1.2).

Un autre exemple :

let result: f64 = 7.8 % 3.5;
// le résultat est 0.8

Défi

Débutant

Écrivez un code qui initialise trois variables, a (i32), b (f64) et c (i32) avec les valeurs 9, 2.6 et 11 (respectivement).

Après cela, initialisez les variables suivantes :

d (i32) qui contiendra le résultat de a modulo 2
e (i32) qui contiendra le résultat de a modulo 3
f (f64) qui contiendra le résultat de b modulo 1.5
g (f64) qui contiendra le résultat de b modulo 3.9
h (i32) qui contiendra le résultat de c modulo 10

Observez le résultat et voyez comment différents dividendes et diviseurs affectent le résultat.

Aide-mémoire

L'opérateur modulo % donne le reste d'une division :

let result = dividend % divisor;

Exemple avec des entiers :

let result = 10 % 3; // le résultat est 1

Cas d'utilisation courant - vérifier si un nombre est pair ou impair :

Nombres pairs : number % 2 == 0
Nombres impairs : number % 2 == 1

Modulo avec des nombres à virgule flottante :

let result: f64 = 5.2 % 2.0; // le résultat est 1.2
let result: f64 = 7.8 % 3.5; // le résultat est 0.8

Essayez vous-même

fn main() {
    // Tapez votre code ci-dessous
    
    
    // Ne modifiez pas la ligne ci-dessous
    println!("a = {}", a);
    println!("b = {}", b);
    println!("c = {}", c);
    println!("d = {}", d);
    println!("e = {}", e);
    println!("f = {}", f);
    println!("g = {}", g);
    println!("h = {}", h);
}