Opérateur de modulo C ++

Selon l'opération passée, le symbole de l'opérateur en programmation demande au compilateur de réaliser une opération spécifique à un numéro spécifique. Diverses opérations (y compris +, -, * et /) sont effectuées sur des nombres en utilisant ce. Y compris différents opérateurs du programme, il aide à améliorer les compétences mathématiques et logiques du programmeur. L'opérateur de module fait l'objet de cette section.

De nombreux langages de programmation utilisent le symbole de l'opérateur du module. Le symbole en pourcentage est utilisé pour le représenter. L'opérateur arithmétique utilise un opérateur appelé module. Il décide de l'équilibre. Dans certaines circonstances, le reste pourrait être nul, ce qui indique que le nombre est entièrement divisible par le diviseur.

Syntaxe de l'opérateur de module en c++

L'opérateur de module suivant est utilisé en C ++:

Syntaxe:

variable_name = valeur1% valeur2

La valeur1 et la valeur2 sont indiquées comme des valeurs entières nécessaires pour le fonctionnement du module. L'opérateur de module représenté par le pourcentage (%) Le signe de la syntaxe susmentionnée divise les deux nombres Value1 et Value2 et renvoie le résidu.

• Les options où seul un résultat restant est obtenu après avoir divisé le premier numéro par le deuxième numéro est le suivant.
• Il renvoie un nombre dans l'intervalle [1, valeur 1 - 1] si la variable n'est pas entièrement divisée par le deuxième entier (valeur2).
• Il génère une erreur au temps de compilation si la première valeur (valeur1) n'est pas nulle et que la deuxième valeur est 0.

Travailler sur l'opérateur de module en C++

L'utilisateur final reçoit deux opérandes pour que l'opérateur de module puisse fonctionner. Le reste est ensuite calculé en divisant les premier et deuxième nombres. Examinons l'exemple qui suit pour comprendre comment fonctionne l'opérateur de module.

Exemple 1

Lorsque deux entiers sont divisés, vous pouvez découvrir un rappel en utilisant l'opérateur de division modulaire. L'exemple suivant spécifie le type de données de la valeur de retour ainsi que le type de données des opérandes.

#inclure
Utilisation de Namespace Std;
int Main (vide)

int var1, var2;
Résultat int;
var1 = 2;
var2 = 5;
Résultat = var1% var2;
couter<< Result <Résultat = var2% var1;
couter<< Result <var1 = 6;
var2 = 8;
Résultat = var1% var2;
couter<retour 0;

Nous avons déclaré deux variables int, «var1» et «var2» et avons également déclaré la troisième variable, «résultat». Ensuite, nous avons attribué la valeur entière à ces variables. À la troisième variable, «résultat», nous avons attribué un opérateur de modulo entre les variables «var1» et «var2». Encore une fois, nous avons utilisé l'opérateur modulo, mais cette fois l'opérande est var2, et le deuxième opérande est var1. Ensuite, nous avons modifié les valeurs des variables «var1» et «var2». L'opérateur modulo est également appliqué aux variables modifiées.

Les différents résultats du module sont générés dans l'écran suivant.

Exemple 2

Il existe de nombreuses contraintes ou limitations placées sur l'opérateur modulo. Les nombres en point flottant, comme Float ou Double, ne peuvent pas être exprimés en utilisant l'opérateur pour cent. Le compilateur générera une erreur si vous essayez d'implémenter le module avec des valeurs ou des variables à virgule flottante.

#inclure
Utilisation de Namespace Std;
int main()

Float Val1, Val2;
Résultat flottant;
val1 = 2.9;
val2 = 1.4;
Résultat = VAL1% VAL2;
couter<retour 0;

Nous avons défini deux variables, «Val1» et «Val2», de Type de données Float. De plus, nous avons créé une autre variable en tant que «résultat» du flotteur de type de données, qui génère le résultat de ces deux variables spécifiées. Ensuite, nous avons attribué les valeurs décimales à ces variables car leur type de données est flottant. Les variables sont invoquées à l'intérieur du «résultat» et de l'opérateur de module appliqué entre eux. La valeur renvoyée du «résultat» est ensuite affichée.

Vous pouvez voir l'exception de compilation est lancée dans la sortie. Cela signifie que nous ne pouvons pas utiliser Float ou toute valeur décimale lors de l'utilisation de l'opérateur de module.

Exemple 3

Pour les opérandes négatifs, le signe de la sortie de l'opérateur modulo dépend de la machine car l'action se produit en conséquence de sous-écoulement ou de débordement.

#inclure
Utilisation de Namespace Std;
int Main (vide)

int num1, num2;
int my_result;
num1 = -7;
num2 = 9;
my_result = num1% num2;
couter<num1 = 7;
num2 = -4;
my_result = num1% num2;
couter<num1 = -7;
num2 = -9;
my_result = num1% num2;
couter<retour 0;

Nous avons créé des variables de type de données int «num1» et «num2». Pour stocker les résultats d'expression du module, nous avons défini la variable «my_result». À la variable «num1», nous avons attribué la valeur négative, et à la variable «num2», l'entier positif est attribué. Ensuite, avec le «my_result», nous avons réglé l'opérateur de module entre les variables «num1» et «num2». Ensuite, nous avons changé les signes du «num1» et «num2». Ensuite, appliquez l'opérateur de module. Encore une fois, nous avons changé les signes des «num1» et «num2», mais cette fois, les deux variables ont des valeurs entières négatives. L'opérateur de module est également appliqué aux variables nouvellement modifiées. Les résultats de chaque module de l'opérateur sont affichés avec la commande cout en passant la variable «my_result».

Dans la sortie, vous pouvez remarquer que les premiers résultats du module génèrent la valeur négative comme Operand1 a un signe négatif. Les deuxièmes résultats du module donnent les valeurs de signe positives car l'opérand2 contient le signe négatif tandis que l'opérand1 a un signe positif. Les derniers résultats du module ont renvoyé les valeurs de signe négatives car les deux opérandes ont des signes négatifs.

Exemple 4

En une seule ligne, la division modulaire peut être effectuée sur plus de deux entrées en utilisant le séquençage de l'opérateur de module.

#inclure
Utilisation de Namespace Std;
int main()

int i = 15;
int j = 7;
int k = 4;
int modulo_res = i% j% k;
couter<< "Modulus result is : "<

Dans l'ensemble de ce programme, nous avons déclaré et initialisé trois variables en tant que «I», «J» et «K», respectivement. Ensuite, nous avons créé une autre variable qui a l'expression du module. Nous l'avons utilisé. Nous avons passé toutes les variables supérieures à initialisés entre l'opérateur du module. Après cela, avec la commande cout, les résultats de l'opérateur de module seront affichés.

Les résultats de l'opérateur de module ayant trois opérandes sont générés comme suit:

Conclusion

Voici un tutoriel C pour l'opérateur du module. Dans cette section, nous passons en revue une introduction à l'opérateur du module, comment cela fonctionne et des exemples de calcul. Trouver la valeur restante des deux entiers nécessite l'opérateur du module C ++. Ici, seuls les entiers sont autorisés. À partir des exemples, seuls les numéros entiers peuvent être utilisés avec l'opérateur de module.