Modulo -operatør C ++

I følge den beståtte operasjonen instruerer operatørsymbolet i programmering kompilatoren til å utføre en spesifikk operasjon med et bestemt nummer. Ulike operasjoner (inkludert +, -, *og /) utføres på tall ved hjelp av dette. Inkludert forskjellige operatører i programmet hjelper det å forbedre programmererens matematiske og logiske ferdigheter. Moduloperatøren er gjenstand for denne delen.

Tallrike programmeringsspråk bruker modulusoperatørens symbol. Prosentsymbolet brukes til å representere det. Den aritmetiske operatøren bruker en operatør som kalles en modul. Det bestemmer balansen. I noen tilfeller kan resten være null, noe som indikerer at antallet er helt delbart med divisoren.

Syntaks av modulusoperatør i C++

Følgende moduloperatør brukes i C ++:

Syntaks:

variabel_navn = verdi1 % verdi2

Verdien1 og verdi2 er indikert som heltallverdier som trengs for moduldrift. Modulusoperatøren representert med prosentvis (%) -tegn i den nevnte syntaksen deler de to tallverdien1 og verdien2 og returnerer resten.

• Alternativene når bare et resten resultat oppnås etter å ha delt det første tallet med det andre nummeret er som følger.
• Det returnerer et tall i intervallet [1, verdi1 - 1] hvis variabelen ikke helt er delt på det andre heltallet (verdi2).
• Det genererer en feil ved samlingen tid hvis den første verdien (verdi1) ikke er null og den andre verdien er 0.

Jobber med moduloperatør i C++

Sluttbrukeren mottar to operander for modulusoperatøren å operere på. Det resterende beregnes deretter ved å dele det første og andre tall. La oss undersøke eksemplet som følger for å forstå hvordan modulusoperatøren fungerer.

Eksempel 1

Når to heltall er delt, kan du oppdage en påminnelse ved hjelp av den modulære divisjonsoperatøren. Følgende eksempel spesifiserer den returnerende verdens datatype så vel som operandenes datatype.

#inkludere
ved hjelp av navneområdet STD;
Int Main (Void)

int var1, var2;
int resultat;
var1 = 2;
var2 = 5;
Resultat = var1 % var2;
cout<< Result <Resultat = var2 % var1;
cout<< Result <var1 = 6;
var2 = 8;
Resultat = var1 % var2;
cout<retur 0;

Vi har erklært to INT -variabler, “var1” og “var2”, og erklærte også den tredje variabelen, “Resultat”. Deretter har vi tildelt heltallverdien til disse variablene. Til den tredje variabelen, "Resultat", har vi tildelt en Modulo -operatør mellom variablene “var1” og “var2”. Igjen har vi brukt Modulo -operatøren, men denne gangen operand en er var2, og den andre operanden er var1. Deretter har vi endret verdiene til variablene “var1” og “var2”. Modulo -operatøren brukes også på de modifiserte variablene.

De forskjellige modulresultatene genereres på følgende skjermbilde.

Eksempel 2

Det er mange begrensninger eller begrensninger som er plassert på Modulo -operatøren. Tall i flytende punkt, for eksempel float eller dobbel, kan ikke uttrykkes ved hjelp av prosentoperatøren. Kompilatoren vil generere en feil hvis du prøver å implementere modulen med flytende punktverdier eller variabler.

#inkludere
ved hjelp av navneområdet STD;
int main ()

Float Val1, Val2;
FLOAT -resultat;
Val1 = 2.9;
Val2 = 1.4;
Resultat = VAL1 % VAL2;
cout<retur 0;

Vi har definert to variabler, “Val1” og “Val2”, av datatype float. Vi har også opprettet en annen variabel som "resultatet" av datatypen float, som genererer resultatet av disse to spesifiserte variablene. Deretter tildelte vi desimalverdiene til disse variablene, da deres datatype er flyte. Variablene påkalles i "resultatet" og anvendt modulusoperatør mellom dem. Den returnerte verdien av "resultat" vises deretter.

Du kan se at kompilasjons unntaket kastes i utgangen. Dette betyr at vi ikke kan bruke float eller noen desimalverdi mens du bruker moduloperatøren.

Eksempel 3

For negative operander avhenger tegnet på utgangen for modulo -operatøren av maskinen fordi handlingen oppstår som en konsekvens av understrømning eller overløp.

#inkludere
ved hjelp av navneområdet STD;
Int Main (Void)

int num1, num2;
int my_result;
num1 = -7;
num2 = 9;
my_result = num1 % num2;
cout<num1 = 7;
num2 = -4;
my_result = num1 % num2;
cout<num1 = -7;
num2 = -9;
my_result = num1 % num2;
cout<retur 0;

Vi har opprettet Int -datatypevariabler “NUM1” og “NUM2”. For å lagre resultatene for modulusuttrykk, har vi definert variabelen "my_result". Til variabelen “num1” har vi tildelt den negative verdien, og til variabelen “num2” er det positive heltallet tildelt. Deretter, med "my_result", har vi satt moduloperatøren mellom "num1" og "num2" -variablene. Deretter har vi endret tegnene til “Num1” og “NUM2”. Brukte deretter modulusoperatøren på dem. Igjen har vi endret tegn på “num1” og “num2”, men denne gangen har begge variablene negative heltallverdier. Moduloperatøren blir også brukt på de nylig modifiserte variablene. Hver moduloperatørs resultater vises med cout -kommandoen ved å sende variabelen “my_result” til den.

I utgangen kan du legge merke til at de første resultatene av modulen genererer den negative verdien ettersom operand1 har et negativt tegn. De andre resultatene av modul gir de positive tegnverdiene da Operand2 inneholder det negative tegnet mens Operand1 har et positivt tegn. De siste resultatene av modulen returnerte de negative skiltverdiene da begge operandene har negative tegn.

Eksempel 4

I en enkelt linje kan modulær inndeling utføres på mer enn to innganger ved å bruke sekvensering av modulusoperatør.

#inkludere
ved hjelp av navneområdet STD;
int main ()

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

Innenfor hovedprogrammet har vi erklært og initialisert tre variabler som henholdsvis "jeg", "j" og "k". Deretter opprettet vi en annen variabel som har moduluttrykket. Vi har brukt det. Vi har passert alle de ovennevnte variablene mellom modulusoperatøren. Etter det, med cout -kommandoen, vises resultatene fra modulusoperatøren.

Resultatene fra modulusoperatøren som har tre operander genereres som følger:

Konklusjon

Her er en C -opplæring for moduloperatøren. I dette avsnittet går vi over en introduksjon til moduloperatøren, hvordan den fungerer og beregningseksempler. Å finne den gjenværende verdien av de to heltallene krever C ++ -moduloperatøren. Her er det bare heltall som er tillatt. Fra eksemplene kan bare heltallstall brukes med moduloperatøren.