HOWTO · C++

Utiliser l'opérateur Modulo en C++

Cet article présente l'utilisation de l'opérateur modulo en C++

Sur cette page

L’opérateur % de C++ renvoie le reste d’une division entière. Par exemple, 10 % 3 vaut 1. Il s’applique aux types intégrals, y compris aux entiers signés, mais pas aux opérandes à virgule flottante. Le diviseur doit être non nul. Le résultat peut servir à vérifier la parité, à parcourir des positions en boucle ou à obtenir un indice de compartiment borné, en tenant compte des valeurs signées si nécessaire.

Valeur renvoyée par l’opérateur % de C++

Pour des entiers a et b, a % b est le reste de a / b. En C++, la division entière est tronquée vers zéro : 10 / 3 vaut donc 3 et 10 % 3 vaut 1. Les deux opérandes doivent être de type intégral ; si l’un d’eux ne l’est pas, l’expression est mal formée. Le diviseur doit également être non nul, car un diviseur nul entraîne un comportement indéfini.

Ce petit programme illustre un calcul positif courant :

#include <iostream>

int main() {
    const int dividend = 17;
    const int divisor = 5;
    std::cout << dividend % divisor << '\n';
}
2

L’opérateur % n’est pas défini pour les valeurs à virgule flottante. Pour obtenir le reste d’une opération sur de telles valeurs, utilisez std::fmod de <cmath>.

Fonctionnement de % avec les entiers signés

Avec des opérandes signés, la division entière est tronquée vers zéro et, lorsqu’il est non nul, le reste a le signe du dividende. Ainsi, -10 % 3 vaut -1, tandis que 10 % -3 vaut 1 ; dans les deux cas, le quotient multiplié par le diviseur, puis additionné au reste, donne le dividende. Ce comportement est défini par C++ et ne dépend pas du choix du compilateur.

Comme un reste négatif reste négatif, % ne produit pas toujours à lui seul un indice non négatif. Pour normaliser le résultat, choisissez un module positif m, stockez value % m dans une variable de reste et ajoutez m uniquement si ce reste est négatif. Puisque le reste est supérieur à -m, le résultat appartient alors à [0, m) sans addition intermédiaire susceptible de déborder. Le quotient doit aussi être représentable : % entraîne un comportement indéfini lorsque le quotient de la division entière correspondante ne peut pas être représenté, par exemple lorsque la valeur minimale d’un type signé est divisée par -1 avec %. L’identité sur le reste donnée plus haut ne s’applique pas à ce cas indéfini.

Vérifier la parité et parcourir des valeurs en boucle avec %

Un entier est pair lorsque value % 2 == 0 ; sinon, il est impair. Cela fonctionne aussi avec les entiers négatifs, car un multiple exact de deux a un reste nul.

Pour parcourir des indices en boucle, utilisez une taille de collection positive et une position non négative :

#include <iostream>

int main() {
    const int values[] = {10, 20, 30};
    const int count = static_cast<int>(sizeof(values) / sizeof(values[0]));

    for (int position = 0; position < 5; ++position) {
        const int index = position % count;
        std::cout << values[index] << '\n';
    }
}
10
20
30
10
20

Le tableau contient trois éléments : chaque indice va donc de 0 à 2, et la suite des positions se répète à mesure que la boucle avance. Ce modèle suppose que la collection contient au moins un élément. Si les positions peuvent être négatives, normalisez le reste avant de l’utiliser comme indice.

Utiliser les restes pour le hachage et les plages de nombres aléatoires

Une table de hachage peut utiliser un reste pour associer une clé non négative à l’un des compartiments d’une table de taille tableSize : key % tableSize. Il faut pour cela que tableSize > 0. Si les clés peuvent être négatives, normalisez le résultat comme indiqué plus haut avant de le convertir en indice. Une véritable table de hachage nécessite aussi une fonction de hachage et une stratégie de gestion des collisions ; le reste ne fait que sélectionner un compartiment dans la plage disponible.

Pour les entiers aléatoires, ne supposez pas que std::rand() % bound produit une distribution uniforme : si le nombre de valeurs possibles du générateur n’est pas un multiple de bound, certains résultats apparaissent plus souvent que d’autres. Pour obtenir une plage entière inclusive, préférez std::uniform_int_distribution avec un moteur aléatoire :

#include <iostream>
#include <random>

int main() {
    std::mt19937 engine(12345);
    std::uniform_int_distribution<int> range(1, 6);
    std::cout << range(engine) << '\n';
}
6

Les paramètres de la distribution définissent les bornes inférieure et supérieure incluses. Avec cette graine, ce moteur et l’implémentation de bibliothèque standard de std::uniform_int_distribution utilisée lors du test, l’exemple affiche 6. C++ n’exige pas que la distribution associe les résultats du moteur de manière identique d’une implémentation de bibliothèque standard à l’autre. La sortie exacte et la séquence ne sont donc pas portables ; elles ne sont reproductibles que si le moteur et l’implémentation de la distribution sont les mêmes. Si vous souhaitez obtenir des séquences différentes, choisissez une source de graines adaptée à votre application.

Utiliser std::modulus comme objet fonction

std::modulus, dans <functional>, est un objet fonction qui applique % à deux valeurs. Il est utile lorsqu’un algorithme attend un objet appelable plutôt qu’une expression utilisant un opérateur :

#include <functional>
#include <iostream>

int main() {
    const std::modulus<int> remainder;
    std::cout << remainder(17, 5) << '\n';
}
2

Ses opérandes obéissent aux mêmes règles de type intégral et de diviseur non nul que %. Dans les expressions courantes, a % b est généralement la notation la plus claire.