In diesem ausführlichen Leitfaden besprechen wir die Operatoren in der C-Programmierung und ihre Typen.
Operatoren und ihre Typen in der C-Programmierung
Operatoren sind Symbole, mit denen bestimmte mathematische Aufgaben ausgeführt werden. Sie werden zur Manipulation der Daten und Variablen verwendet. Im Folgenden sind die verschiedenen Arten von Operatoren in der C-Programmierung aufgeführt:
- Rechenzeichen
- Unäre Operatoren
- Zuweisungsoperatoren
- Logische oder boolesche Operatoren
- Vergleichsoperatoren
- Bedingte Operatoren
- Bitweise Operatoren
1: Arithmetische Operatoren
Dies sind die Operatoren, mit denen grundlegende mathematische Funktionen wie Addition, Subtraktion oder Multiplikation ausgeführt werden. Sie können diese Operatoren für fast alle integrierten Datentypen der C-Programmierung verwenden. Die folgenden arithmetischen Operatoren werden in der C-Programmierung verwendet:
| Betreiber | Funktionen |
| + | Fügen Sie 2 Operanden hinzu |
| – | Subtrahiere 2 Operanden |
| * | Multiplizieren Sie 2 Operanden |
| / | Dividiere 2 Operanden |
| % | Der Moduloperator gibt den Rest der Division an |
Beispiel
Im folgenden Beispiel haben wir die oben genannten arithmetischen Operationen an der Variablen X und der Variablen Y durchgeführt. Die Variable X enthält den Wert 20 und Y den Wert 5:
#include
int hauptsächlich ( )
{
int X = zwanzig ;
int UND = 5 ;
int Ergebnis ;
Ergebnis = X + UND ;
printf ( „Die Addition von X und Y beträgt: %d \N ' , Ergebnis ) ;
Ergebnis = X - UND ;
printf ( „Die Subtraktion von X und Y beträgt: %d \N ' , Ergebnis ) ;
Ergebnis = X * UND ;
printf ( „Die Multiplikation von X und Y beträgt: %d \N ' , Ergebnis ) ;
Ergebnis = X / UND ;
printf ( „Die Division von X und Y ist: %d \N ' , Ergebnis ) ;
Ergebnis = X % UND ;
printf ( „Modulteilung von X und Y ist: %d \N ' , Ergebnis ) ;
zurückkehren 0 ;
}
2: Unäre Operatoren
Es gibt zwei einzigartige unäre Operatoren, die nur von der C-Sprache unterstützt werden: Inkrement-++- und Dekrement-Operatoren. Der Inkrementoperator addiert 1 zum Operanden und der Dekrementoperator subtrahiert 1 vom Operanden.
Der Inkrementoperator wird wie folgt geschrieben:
++ ein oder ein ++
Der Dekrementoperator lautet:
-- ein oder ein --Wenn wir den Inkrementierungs- und Dekrementierungsoperator als Präfix verwenden, addiert oder subtrahiert er zuerst den Variablenwert und dann wird das Ergebnis der Variablen links zugewiesen. Wenn die Operatoren vorher addiert werden, wird zuerst der ursprüngliche Wert zurückgegeben und dann wird der Operand um 1 addiert oder subtrahiert.
Beispiel
Nachfolgend haben wir zwei Variablen a und b Werte zugewiesen und auf sie Inkrementierungs- und Dekrementierungsoperatoren angewendet:
#includeint hauptsächlich ( )
{
int A = fünfzehn , B = 10 ;
printf ( '++a = %d \N ' , ++ A ) ;
printf ( 'a++ = %d \N ' , A ++ ) ;
zurückkehren 0 ;
}
3: Zuweisungsoperator
Ein Zuweisungsoperator (=) wird verwendet, um der Variablen im Programm den Wert zuzuweisen. Nachfolgend sind die Zuweisungsoperatoren aufgeführt:
| Betreiber | Funktion |
| = | Weisen Sie dem Operanden die Werte zu |
| += | Addieren Sie den Wert des rechts vorhandenen Operanden zum linken Operanden |
| -= | Subtrahieren Sie den Wert des rechten Operanden vom linken Operanden |
| *= | Multiplizieren Sie den Wert des rechten Operanden mit dem linken Operanden |
| /= | Teilen Sie den Wert des rechten Operanden durch den linken Operanden |
| %= | Nehmen Sie den Modul zweier Werte und weisen Sie den Wert dem linken Operanden zu |
Beispiel
Wir haben die Funktionsweise der Zuweisungsoperatoren auf die beiden Operanden X und Y im folgenden Beispiel demonstriert:
#includeint hauptsächlich ( )
{
int X = 10 ;
int Ergebnis ;
Ergebnis = X ;
printf ( „Wert des Ergebnisses = %d \N ' , Ergebnis ) ;
Ergebnis += X ;
printf ( „Wert des Ergebnisses = %d \N ' , Ergebnis ) ;
Ergebnis -= X ;
printf ( „Wert des Ergebnisses = %d \N ' , Ergebnis ) ;
Ergebnis *= X ;
printf ( „Wert des Ergebnisses = %d \N ' , Ergebnis ) ;
Ergebnis /= X ;
printf ( „Wert des Ergebnisses = %d \N ' , Ergebnis ) ;
zurückkehren 0 ;
}
4: Vergleichsoperatoren
Die Vergleichsoperatoren werden in der C-Programmierung verwendet, um die Beziehung zwischen zwei Variablen zu überprüfen. Es kann verwendet werden, um die Preise der Artikel oder das Alter zweier Personen zu vergleichen. Die folgenden relationalen Operatoren werden in der C-Programmierung verwendet:
| Betreiber | Funktionen |
| == | Gleich |
| > | Größer als |
| < | Weniger als |
| >= | Größer als gleich |
| <= | Weniger als gleich |
| != | Nicht gleichzusetzen mit |
Beispiel
Das folgende Beispiel zeigt die Funktionsweise der Vergleichsoperatoren in der C-Programmierung:
#includeint hauptsächlich ( )
{
int A = 9 ;
int B = 10 ;
printf ( „%d == %d ist %d \N ' , A , B , A == B ) ;
printf ( „%d > %d ist %d \N ' , A , B , A > B ) ;
printf ( „%d < %d ist %d \N ' , A , B , A < B ) ;
printf ( „%d != %d ist %d \N ' , A , B , A != B ) ;
printf ( „%d >= %d ist %d \N ' , A , B , A >= B ) ;
printf ( „%d <= %d ist %d \N ' , A , B , A <= B ) ;
zurückkehren 0 ;
}
5: Logische Operatoren
Es gibt vier logische Operatoren, die von der C-Sprache unterstützt werden:
| Betreiber | Funktion |
| Logisches UND (&&) | Nur wahr, wenn alle Bedingungen erfüllt sind |
| Logisches ODER (||) | Wenn nur eine Bedingung erfüllt ist, ist das Ergebnis wahr |
| Logisches NICHT(!) | Wenn Operand 0 ist, ist das Ergebnis wahr |
| Bitweise NICHT (~). | Invertiert alle Bits des Operanden |
Beispiel
Der folgende Beispielcode erklärt die Funktionsweise der logischen Operatoren in C:
#includeint hauptsächlich ( )
{
int X = 10 , UND = 4 , MIT = 10 , Ergebnis ;
Ergebnis = ( X == UND ) && ( MIT > UND ) ;
printf ( '(X == Y) && (Z > Y) ist %d \N ' , Ergebnis ) ;
Ergebnis = ( X == UND ) && ( MIT < UND ) ;
printf ( „(X == Y) && (Z < Y) ist %d \N ' , Ergebnis ) ;
Ergebnis = ( X == UND ) || ( MIT < UND ) ;
printf ( '(X == Y) || (Z < Y) ist %d \N ' , Ergebnis ) ;
Ergebnis = ( X != UND ) || ( MIT < UND ) ;
printf ( '(X != Y) || (Z < Y) ist %d \N ' , Ergebnis ) ;
Ergebnis = ! ( X != UND ) ;
printf ( '!(X != Y) ist %d \N ' , Ergebnis ) ;
Ergebnis = ! ( X == UND ) ;
printf ( '!(X == Y) ist %d \N ' , Ergebnis ) ;
Ergebnis = ! ( X > UND ) ;
printf ( '!(X > Y) ist %d \N ' , Ergebnis ) ;
zurückkehren 0 ;
}
6: Bedingte Operatoren
Der Bedingungsoperator in C wird auch als „The“ bezeichnet ternärer Operator weil es drei Operanden benötigt – die Bedingung, Anweisung 1 und Anweisung 2. Es wertet die Bedingung aus und gibt entweder Anweisung 1 oder Anweisung 2 zurück, abhängig vom Ergebnis einer bestimmten Bedingung, die entweder wahr oder falsch sein kann
Zustand ? Stellungnahme 1 : Stellungnahme 2- Zustand: Ein boolescher Ausdruck, der prüft, ob er wahr oder falsch ist.
- Aussage 1: Ein Ausdruck, der ausgewertet wird, wenn die Bedingung wahr ist.
- Aussage 2: Ein Ausdruck, der ausgewertet wird, wenn die Bedingung falsch ist.
Beispiel
Im folgenden Beispiel habe ich der Zahl den Wert zugewiesen und dann die Bedingung angewendet. Wenn die Bedingung wahr ist, wird Anweisung 1 ausgegeben, und wenn die Bedingung falsch ist, wird Anweisung zwei ausgegeben:
#includeint hauptsächlich ( )
{
int Nummer = 10 ;
( Nummer < zwanzig ) ? ( printf ( „Es ist weniger als Nummer 20!“ ) ) : ( printf ( „Es ist größer als Nummer 20!“ ) ) ;
zurückkehren 0 ;
}
7: Bitweise Operatoren
Bitweise Operatoren in C manipulieren Daten auf Bitebene, das heißt, sie bearbeiten einzelne Bits innerhalb von Datentypen wie Ganzzahlen. Sie können nicht auf Double und Float angewendet werden und werden zum Testen der Bits und zum Verschieben nach rechts oder links verwendet.
Bitweise Operatoren in der C-Programmierung sind in der folgenden Tabelle aufgeführt:
| Betreiber | Funktion |
| & | Bitweises UND |
| | | Bitweises ODER |
| ^ | Bitweises Exklusiv-ODER |
| << | Nach links verschieben |
| >> | Nach rechts verschieben |
| ~ | Einerkomplement |
Beispiel
Das folgende Beispiel zeigt ein C-Programm, das bitweise Operatoren verwendet:
#includeint hauptsächlich ( ) {
int A = 13 ; // binär 1101
int B = 7 ; // binär 0111
int Ergebnis ;
// Bitweises UND
Ergebnis = A & B ; // 1101 & 0111 = 0101 (dezimal 5)
printf ( 'a & b = %u \N ' , Ergebnis ) ;
// Bitweises ODER
Ergebnis = A | B ; // 1101 | 0111 = 1111 (dezimal 15)
printf ( 'a | b = %u \N ' , Ergebnis ) ;
// Bitweises XOR
Ergebnis = A ^ B ; // 1101 ^ 0111 = 1010 (dezimal 10)
printf ( 'a ^ b = %u \N ' , Ergebnis ) ;
// Bitweise Linksverschiebung
Ergebnis = A << 2 ; // 1101 << 2 = 110100 (dezimal 52)
printf ( 'a << 2 = %u \N ' , Ergebnis ) ;
// Bitweise Rechtsverschiebung
Ergebnis = A >> 2 ; // 1101 >> 2 = 0011 (Dezimal 3)
printf ( 'a >> 2 = %u \N ' , Ergebnis ) ;
// Bitweise NICHT
Ergebnis = ~a ; // ~1101 = 0010 (dezimale Zweierkomplementdarstellung von -14)
printf ( '~a = %d \N ' , Ergebnis ) ;
zurückkehren 0 ;
}
Notiz: Bitweise Operatoren werden verwendet, um Aufgaben auf Bitebene auszuführen, das heißt, sie bearbeiten einzelne Bits innerhalb einer Binärzahl. Boolesche Operatoren hingegen werden verwendet, um Operationen an logischen Werten auszuführen. Sie arbeiten mit booleschen Werten (wahr/falsch oder 1/0) und werden häufig in Entscheidungsprozessen oder bedingten Anweisungen verwendet.
Endeffekt
Ein Operator ist ein Symbol, das den Compiler anweist, bestimmte Funktionen auszuführen. Die C-Sprache verfügt über mehrere integrierte Operatoren, darunter arithmetische, unäre, Zuweisungs-, logische, relationale, bedingte, boolesche und bitweise Operatoren. Wir haben sie ausführlich besprochen und anhand der Beispielausgabe demonstriert. Lesen Sie den obigen Abschnitt des Leitfadens, um detaillierte Informationen zu diesen Betreibern zu erhalten.