Opérateur modulo en c

L'opérateur modulo est un opérateur arithmétique couramment utilisé dans les langages de programmation. Cet opérateur est utilisé pour découvrir le reste après avoir effectué une division entre les deux nombres entiers ou variables. Par exemple, si nous divisons 5 par 2, nous obtiendrons un reste de 1, où 5 est le dividende, 2 est le diviseur, et 1 est le reste. Dans le langage de programmation C, l'opérateur modulo est représenté par le pourcentage de symbole: %. Un exemple de cas d'utilisation de l'opérateur modulo est de savoir si le nombre est uniforme ou impair. Nous pouvons également utiliser cet opérateur pour savoir si les deux nombres sont des facteurs l'un de l'autre ou non. L'expression de l'opérateur de module est un% b = c ici, et c est le reste.

Syntaxe générale

Pour une arithmétique généralisée où il souhaité faire du module, nous avons les mathématiques suivantes:

// Créer 2 nombres
NUMÉRO 1
NUMÉRO 2
// diviser un numéro par l'autre
Number1 / Number2
// deux sorties sont créées
Résultats_of_division
RESTE

La syntaxe généralisée pour faire un modulo en C est la suivante:

int number1;
int number2;
Reste = nombre 1% nombre2;

Ce guide nous fera savoir comment nous pouvons utiliser l'opérateur de module pour développer diverses logiques dans nos codes par démonstration de quelques exemples.

Exemple # 01

Dans l'ensemble, déclarez deux variables «A» et «B», puis les initialiser en attribuant certaines valeurs numériques, E.g., 5 et 4 respectivement. Après cette initialisation, introduisez une autre variable de type de données entier et nommez-le modulo. Attribuez le module d'un% B à cette variable et affichez le module à l'aide de la fonction printf ().

#inclure
void main ()
int a = 5;
int b = 4;
module int = a% b;
printf ("reste de la division% d,% d est% d \ n", a, b, module);
Linuxhint @: ~ $ ./ modulo
Le reste de la division 5, 4 est 1
Linuxhint @: ~ $

L'exemple ci-dessus a renvoyé la sortie 1, qui est le reste résultant du module de 5 et 4.

Exemple # 02

Si nous devons prendre le module de plus de deux variables à la fois, nous pouvons transformer notre opérateur de module en opérateur de module de chaîne. L'opérateur de module de chaîne prend le module entre plus de deux variables simultanément sans gaspiller un espace supplémentaire et un temps de déclaration sur chacune des variables séparément.

Nous implémenterons ce type de module sur l'exemple suivant. Nous inclurons les fichiers d'en-tête importants pour l'impression et la numérisation de l'entrée et de la sortie et déclarent ensuite les quatre variables différentes A, B, C et D avec le type de données comme entier. Après cette déclaration de variables, nous initialiserons ces variables en attribuant leurs valeurs. Ensuite, nous prendrons le module collectif de toutes ces variables dans une chaîne et enregistrerons la valeur résultante dans une autre variable avec le type de données int puis afficher cette valeur en sortie.

#inclure
int main ()
int a; int b; INT C; int d;
a = 5; b = 4; c = 3; d = 2;
int modulo = a% b% c% d;
printf ("% d \ n", modulo);
retour 0;
Linuxhint @ U20: ~ $ ./ modulo
1
linuxhint @ u20: ~ $

La sortie affiche le module de chaîne des quatre variables A, B, C et D pour la sortie qui est le résultat de 1:

5% 4 ==> 1
1% 3 ==> 1
1% 2 ==> 1

Exemple # 03

Dans cet exemple, nous apprendrons comment nous pouvons utiliser l'opérateur de module pour vérifier si le nombre est uniforme ou impair. À cette fin, nous prendrons simplement le module du nombre et si le résultat est 0, c'est un nombre pair et si le résultat est 1 que c'est un nombre impair. Nous mettons cela dans une fonction et utilisons la fonction pour tester diverses entrées. Nous créons également une fonction d'affichage d'impression pour rendre le programme plus élégant:

#inclure
void Affichage (int entrée, int bid)
si (Odd == 1)
printf ("Le numéro d'entrée% d est impairs \ n", entrée);
autre
printf ("Le nombre d'entrée% d est même \ n", entrée);

int is_odd (int entrée)
int reste = entrée% 2;
// retour de 1 quand il est étrange
// retour de 0 quand même
Retour reste;

void main ()
Résultat int;
int userInput;
// Tester 1
result = is_odd (1);
affichage (1, résultat);
// Tester 2
result = is_odd (2);
affichage (2, résultat);
// Tester 3
result = is_odd (3);
affichage (3, résultat);
// Tester 4
result = is_odd (4);
affichage (4, résultat);
// Test basé sur la saisie de l'utilisateur
printf ("Entrez votre numéro:");
scanf ("% d" et userInput);
result = is_odd (userInput);
Affichage (userInput, résultat);
sysads @ u20: ~ $ ./ mod
L'entrée numéro 1 est impair
L'entrée numéro 2 est uniforme
Le numéro d'entrée 3 est impair
Le numéro d'entrée 4 est uniforme
Entrez votre numéro: 33
Le numéro d'entrée 33 est impair

Conclusion

L'opérateur de module est un opérateur arithmétique pour la langue C. Cet article met en évidence l'utilisation de l'opérateur de module pour diverses fonctions. Nous avons appris la syntaxe de base et la représentation de l'opérateur de module en C. Vous pouvez également voir un exemple de fonction avec une opération de module pour vérifier les nombres uniques ou impairs et pour prendre le module simple et chaîne pour plusieurs variables.