Modulo -Operator in C

Der Modulo -Operator ist ein häufig verwendeter arithmetischer Operator in Programmiersprachen. Dieser Bediener wird verwendet, um den Rest herauszufinden, nachdem wir die Abteilung zwischen den beiden Ganzzahlzahlen oder Variablen durchgeführt haben. Wenn wir beispielsweise 5 durch 2 teilen, erhalten wir einen Rest von 1, wobei 5 die Dividende ist, 2 der Divisor und 1 der Rest ist. In der C -Programmiersprache wird der Modulo -Operator durch das prozentuale Symbol dargestellt: %. Ein Beispiel -Anwendungsfall des Modulo -Operators besteht darin, festzustellen, ob die Zahl gerade oder ungerade ist. Wir können diesen Bediener auch verwenden, um festzustellen, ob die beiden Zahlen Faktoren voneinander sind oder nicht. Der Ausdruck für den Modul -Operator ist hier A% b = C, und C ist der Rest.

Allgemeine Syntax

Für eine verallgemeinerte Arithmetik, bei der es sich um einen Modul erwerben wollte, haben wir die folgende Mathematik:

// 2 Zahlen erstellen
NUMMER 1
NUMMER 2
// eine Nummer durch die andere teilen
Nummer1 / Nummer2
// Es werden zwei Ausgänge erstellt
RESSERS_OF_DIVISION
REST

Die verallgemeinerte Syntax, um ein Modulo in C zu machen, lautet wie folgt:

int Nummer1;
int Nummer2;
Rest = Nummer1 % Nummer2;

Mit diesem Leitfaden können wir mit dem Modul -Operator wissen, wie wir in unseren Codes verschiedene Logik entwickeln können, indem wir einige Beispiele demonstrieren können.

Beispiel # 01

Deklarieren Sie im Hauptteil zwei Variablen "A" und "B" und initialisieren Sie sie, indem Sie einige numerische Werte zuweisen, e.G., 5 bzw. 4. Führen Sie nach dieser Initialisierung eine andere Variable des Datentyp -Integer ein und nennen Sie es Modulo. Weisen Sie dieser Variablen den Modul eines % b zu und zeigen Sie den Modul mit der Funktion printf () an.

#enthalten
void main ()
int a = 5;
int b = 4;
int modulus = a % b;
printf ("Rest der Division %d, %d ist %d \ n", a, b, modulus);
LinuxHint@: ~ $ ./Modulo
Rest der Division 5, 4 ist 1
LinuxHint@: ~ $

Das obige Beispiel hat den Ausgang 1 zurückgegeben, der der Rest ist, der sich aus dem Modul von 5 und 4 ergibt.

Beispiel # 02

Wenn wir den Modul von mehr als zwei Variablen gleichzeitig einnehmen müssen, können wir unseren Modul -Operator in den Kettenmodul -Bediener verwandeln. Der Kettenmodul -Operator nimmt das Modulo zwischen mehr als zwei Variablen gleichzeitig, ohne zusätzlichen Platz und Deklarationszeit für jede der Variablen separat zu verschwenden.

Wir werden diese Art von Modul am nächsten Beispiel implementieren. Wir werden die wichtigen Header -Dateien für den Druck und Scan der Eingabe und Ausgabe einschließen und dann die vier verschiedenen Variablen A, B, C und D mit dem Datentyp als Ganzzahl deklarieren. Nach dieser Variablenerklärung werden wir diese Variablen initialisieren, indem wir ihre Werte zuweisen. Dann nehmen wir den kollektiven Modul all dieser Variablen in einer Kette ein und speichern den resultierenden Wert in einer anderen Variablen mit Datentyp int und dann diesen Wert als Ausgabe anzeigen.

#enthalten
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);
Rückkehr 0;
LinuxHint@u20: ~ $ ./Modulo
1
LinuxHint@u20: ~ $

Der Ausgang zeigt den Kettenmodul aller vier Variablen A, B, C und D für den Ausgang, der ein Ergebnis von 1 ist:

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

Beispiel # 03

In diesem Beispiel erfahren wir, wie wir den Modul -Operator verwenden können, um zu überprüfen, ob die Nummer gerade oder ungerade ist. Zu diesem Zweck nehmen wir einfach den Modul der Zahl ein und wenn das Ergebnis 0 ist, ist es eine gleichmäßige Zahl und wenn das Ergebnis 1 ist als eine ungerade Zahl. Wir setzen dies in eine Funktion ein und verwenden die Funktion, um verschiedene Eingänge zu testen. Wir erstellen auch eine Druckanzeigefunktion, um das Programm eleganter zu gestalten:

#enthalten
void Display (int Eingabe, int ungerade)
if (ungerade == 1)
printf ("Die Eingangszahl %d ist ungerade \ n", Eingabe);
anders
printf ("Die Eingangszahl %d ist sogar \ n", Eingabe);

int is_odd (int input)
int Rest = Eingabe % 2;
// Rückkehr von 1, wenn ungerade
// Rückkehr von 0, wenn überhaupt
Rückstand;

void main ()
int Ergebnis;
int userInput;
// Test 1
result = is_odd (1);
Anzeige (1, Ergebnis);
// Test 2
result = is_odd (2);
Anzeige (2, Ergebnis);
// Test 3
result = is_odd (3);
Anzeige (3, Ergebnis);
// Test 4
result = is_odd (4);
Anzeige (4, Ergebnis);
// Test basierend auf der Benutzereingabe
printf ("Geben Sie Ihre Nummer ein:");
scanf ("%d", & userInput);
result = is_odd (userInput);
Anzeige (UserInput, Ergebnis);
sysads@u20: ~ $ ./mod
Die Eingangsnummer 1 ist ungerade
Die Eingangsnummer 2 ist gerade
Die Eingangsnummer 3 ist ungerade
Die Eingangsnummer 4 ist gerade
Geben Sie Ihre Nummer ein: 33
Die Eingangsnummer 33 ist ungerade

Abschluss

Der Moduloperator ist ein arithmetischer Operator für die C -Sprache. Dieser Artikel zeigt die Verwendung des Modul -Operators für verschiedene Funktionen. Wir haben die grundlegende Syntax und die Darstellung des Moduloperators in C gelernt. Sie können auch eine Beispielfunktion mit einem Moduloperation sehen, um sogar oder ungerade Zahlen zu überprüfen und den einfachen und Kettenmodul für mehrere Variablen zu nehmen.