Modulo -operatør i C

Modulo -operatøren er en ofte brukt aritmetisk operatør i programmeringsspråk. Denne operatøren brukes til å finne ut resten etter at vi har utført deling mellom de to heltallstallene eller variablene. For eksempel, hvis vi deler 5 med 2, vil vi få en resten av 1, der 5 er utbyttet, 2 er divisoren, og 1 er resten. På C -programmeringsspråk er Modulo -operatøren representert med prosentsymbolet: %. Et eksempel på bruk av Modulo -operatøren er å finne om nummeret er jevnt eller rart. Vi kan også bruke denne operatøren til å finne om de to tallene er faktorer for hverandre eller ikke. Uttrykket for modulusoperatøren er en% b = c her, og c er resten.

Generell syntaks

For en generalisert aritmetikk der det er ønsket å gjøre modul, har vi følgende matematikk:

// Opprett 2 tall
NUMMER1
NUMMER 2
// Del det ene tallet med det andre
NUMMER1 / NUMMER2
// To utganger opprettes
Resultater_of_division
REST

Den generaliserte syntaksen for å gjøre en modul i C er som følger:

int nummer1;
int nummer2;
Resten = nummer1 % nummer2;

Denne guiden vil gi oss beskjed om hvordan vi kan bruke moduloperatøren til å utvikle forskjellige logikk i kodene våre ved å demonstrere noen få eksempler.

Eksempel nr. 01

I hovedsak erklærer to variabler “a” og “b”, og initialiser dem deretter ved å tilordne noen numeriske verdier, e.g., Henholdsvis 5 og 4. Etter denne initialiseringen, introduserer du en annen variabel av datatype heltall og navngir den modulo. Tilordne modulen til en % b til denne variabelen og vis modulen ved hjelp av printf () -funksjonen.

#inkludere
void main ()
int a = 5;
int b = 4;
int modulus = a % b;
printf ("resten av divisjon %d, %d er %d \ n", a, b, modul);
linuxhint@: ~ $ ./modulo
Resten av divisjon 5, 4 er 1
linuxhint@: ~ $

Eksemplet ovenfor har returnert utgangen 1, som er resten som følge av modulen 5 og 4.

Eksempel # 02

Hvis vi er pålagt å ta modulen til mer enn to variabler om gangen, kan vi transformere modulusoperatøren vår til kjedemoduloperatøren. Kjedemoduloperatøren tar modulen mellom mer enn to variabler samtidig uten å kaste bort ekstra plass og erklæringstid på hver av variablene hver for seg.

Vi vil implementere denne typen modul på neste eksempel. Vi vil inkludere de viktige overskriftsfilene for utskrift og skanning av inngangen og outputand og deretter erklære de fire forskjellige variablene A, B, C og D med datatypen som heltall. Etter denne variablene erklæres, vil vi initialisere disse variablene ved å tilordne verdiene deres. Da vil vi ta den kollektive modulen til alle disse variablene i en kjede og lagre den resulterende verdien i en annen variabel med datatype int og viser deretter denne verdien som en utgang.

#inkludere
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);
retur 0;
linuxhint@u20: ~ $ ./modulo
1
linuxhint@u20: ~ $

Utgangen viser kjedemodulen til alle de fire variablene A, B, C og D for utgangen som er et resultat av 1:

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

Eksempel # 03

I dette eksemplet vil vi lære hvordan vi kan bruke moduloperatøren for å bekrefte om nummeret er jevnt eller rart. For dette formålet vil vi ganske enkelt ta modulen til tallet, og hvis resultatet er 0, er det et jevnt tall, og hvis resultatet er 1 enn det er et oddetall. Vi legger dette inn i en funksjon og bruker funksjonen til å teste forskjellige innganger. Vi lager også en utskriftsfunksjon for å gjøre programmet mer elegant:

#inkludere
void display (int input, int odd)
if (odd == 1)
printf ("Inngangsnummeret %d er odd \ n", inngang);
ellers
printf ("Inngangsnummeret %d er jevn \ n", inngang);

int is_odd (int input)
int resten = inngang % 2;
// Retur på 1 når det er merkelig
// Retur på 0 når til og med
returner resten;

void main ()
int resultat;
int userInput;
// Test 1
Resultat = IS_ODD (1);
skjerm (1, resultat);
// Test 2
Resultat = IS_ODD (2);
skjerm (2, resultat);
// Test 3
Resultat = IS_ODD (3);
skjerm (3, resultat);
// Test 4
Resultat = IS_ODD (4);
skjerm (4, resultat);
// test basert på brukerinngang
printf ("Skriv inn nummeret ditt:");
SCANF ("%D", & UserInput);
resultat = is_odd (userInput);
display (userInput, resultat);
sysads@u20: ~ $ ./mod
Inngangsnummer 1 er merkelig
Inngang nummer 2 er jevn
Inngangsnummer 3 er merkelig
Inngang nummer 4 er jevn
Skriv inn nummeret ditt: 33
Inngangsnummeret 33 er merkelig

Konklusjon

Modulusoperatøren er en aritmetisk operatør for C -språket. Denne artikkelen belyser bruken av moduloperatøren for forskjellige funksjoner. Vi har lært om den grunnleggende syntaksen og representasjonen av moduloperatøren i C. Du kan også se en prøvefunksjon med en moduloperasjon for å sjekke jevne eller rare tall og for å ta den enkle og kjedemodulen for flere variabler.