In deze gedetailleerde gids bespreken we de operators in C-programmering en hun typen.
Operators en hun typen in C-programmering
Operatoren zijn de symbolen die worden gebruikt om specifieke wiskundige taken uit te voeren. Ze worden gebruikt om de gegevens en variabelen te manipuleren. Hieronder volgen de verschillende soorten operators in C-programmering:
- Rekenkundige operatoren
- Unaire operatoren
- Toewijzing operators
- Logische of Booleaanse operatoren
- relationele operatoren
- Voorwaardelijke operatoren
- Bitsgewijze operatoren
1: Rekenkundige operatoren
Dit zijn de operatoren die worden gebruikt om elementaire wiskundige functies uit te voeren, zoals optellen, aftrekken of vermenigvuldigen. U kunt deze operators gebruiken op bijna alle ingebouwde gegevenstypen van C-programmering. De volgende zijn de rekenkundige operatoren die worden gebruikt in C-programmering:
| Exploitanten | Functies |
| + | Voeg 2 operanden toe |
| – | Trek 2 operanden af |
| * | Vermenigvuldig 2 operanden |
| / | Deel 2 operanden |
| % | De modulusoperator geeft de rest van de deling |
Voorbeeld
In het onderstaande voorbeeld hebben we de bovengenoemde rekenkundige bewerkingen uitgevoerd op de variabele X en variabele Y. De variabele X heeft de waarde 20 en Y heeft de waarde 5:
#include
int voornaamst ( )
{
int X = twintig ;
int EN = 5 ;
int resultaat ;
resultaat = X + EN ;
printf ( 'Optellen van X en Y is: %d \N ' , resultaat ) ;
resultaat = X - EN ;
printf ( 'Aftrekken van X en Y is: %d \N ' , resultaat ) ;
resultaat = X * EN ;
printf ( 'Vermenigvuldiging van X en Y is: %d \N ' , resultaat ) ;
resultaat = X / EN ;
printf ( 'Deling van X en Y is: %d \N ' , resultaat ) ;
resultaat = X % EN ;
printf ( 'Modulusverdeling van X en Y is: %d \N ' , resultaat ) ;
opbrengst 0 ;
}
2: Unaire operatoren
Er zijn twee unieke unaire operatoren die alleen worden ondersteund door C-taal, increment ++ en decrement — operators. De toename-operator telt 1 op bij de operand en de verlagen-operator trekt 1 af van de operand.
De toename-operator wordt geschreven als:
++ een of een ++
De decrement-operator is:
-- een of een --Als we de operator voor verhogen en verlagen als voorvoegsel gebruiken, wordt eerst de waarde van de variabele opgeteld of afgetrokken en vervolgens wordt het resultaat toegewezen aan de variabele links. Als de operatoren eerder zijn toegevoegd, wordt eerst de oorspronkelijke waarde geretourneerd en vervolgens wordt de operand met 1 opgeteld of afgetrokken.
Voorbeeld
Hieronder hebben we waarden toegewezen aan twee variabelen a en b en daarop operatoren voor verhogen en verlagen toegepast:
#includeint voornaamst ( )
{
int A = vijftien , B = 10 ;
printf ( '++a = %d \N ' , ++ A ) ;
printf ( 'a++ = %d \N ' , A ++ ) ;
opbrengst 0 ;
}
3: Toewijzing Operator
Een toewijzingsoperator (=) wordt gebruikt voor het toekennen van de waarde aan de variabele in het programma. Hieronder staan de toewijzingsoperators vermeld:
| Exploitanten | Functie |
| = | Ken de waarden toe aan de operand |
| += | Voeg de waarde van de operand aan de rechterkant toe aan de linker operand |
| -= | Trek de waarde van de rechter operand af van de linker operand |
| *= | Vermenigvuldig de waarde van de rechter operand met de linker operand |
| /= | Deel de waarde van de rechter operand door de linker operand |
| %= | Neem de modulus van twee waarden en wijs de waarde toe aan de linker operand |
Voorbeeld
We hebben de werking van de toewijzingsoperatoren op de twee operanden X en Y gedemonstreerd in het onderstaande voorbeeld:
#includeint voornaamst ( )
{
int X = 10 ;
int resultaat ;
resultaat = X ;
printf ( 'Waarde van resultaat = %d \N ' , resultaat ) ;
resultaat += X ;
printf ( 'Waarde van resultaat = %d \N ' , resultaat ) ;
resultaat -= X ;
printf ( 'Waarde van resultaat = %d \N ' , resultaat ) ;
resultaat *= X ;
printf ( 'Waarde van resultaat = %d \N ' , resultaat ) ;
resultaat /= X ;
printf ( 'Waarde van resultaat = %d \N ' , resultaat ) ;
opbrengst 0 ;
}
4: relationele operatoren
De relationele operatoren worden in C-programmering gebruikt om de relatie tussen twee variabelen te controleren. Het kan worden gebruikt om de prijzen van de items of de leeftijd van twee personen te vergelijken. De volgende zijn de relationele operatoren die worden gebruikt in C-programmering:
| Exploitanten | Functies |
| == | Gelijk aan |
| > | Groter dan |
| < | Minder dan |
| >= | Groter dan gelijk aan |
| <= | Minder dan gelijk aan |
| != | Niet gelijk aan |
Voorbeeld
Het onderstaande voorbeeld toont de werking van de relationele operatoren in C-programmering:
#includeint voornaamst ( )
{
int A = 9 ;
int B = 10 ;
printf ( '%d == %d is %d \N ' , A , B , A == B ) ;
printf ( '%d > %d is %d \N ' , A , B , A > B ) ;
printf ( '%d < %d is %d \N ' , A , B , A < B ) ;
printf ( '%d != %d is %d \N ' , A , B , A != B ) ;
printf ( '%d >= %d is %d \N ' , A , B , A >= B ) ;
printf ( '%d <= %d is %d \N ' , A , B , A <= B ) ;
opbrengst 0 ;
}
5: Logische operatoren
Er zijn vier logische operatoren die worden ondersteund door C-taal:
| Exploitanten | Functie |
| Logische EN (&&) | Alleen waar als aan alle voorwaarden is voldaan |
| Logische OR (||) | Als slechts één voorwaarde voldoet, is het resultaat waar |
| Logisch NIET(!) | Als Operand 0 is, is het resultaat waar |
| Bitsgewijze NIET (~). | Inverteert alle bits van de operand |
Voorbeeld
De onderstaande voorbeeldcode legt de werking van de logische operatoren in C uit:
#includeint voornaamst ( )
{
int X = 10 , EN = 4 , MET = 10 , resultaat ;
resultaat = ( X == EN ) && ( MET > EN ) ;
printf ( '(X == Y) && (Z > Y) is %d \N ' , resultaat ) ;
resultaat = ( X == EN ) && ( MET < EN ) ;
printf ( '(X == Y) && (Z < Y) is %d \N ' , resultaat ) ;
resultaat = ( X == EN ) || ( MET < EN ) ;
printf ( '(X == Y) || (Z < Y) is %d \N ' , resultaat ) ;
resultaat = ( X != EN ) || ( MET < EN ) ;
printf ( '(X != Y) || (Z < Y) is %d \N ' , resultaat ) ;
resultaat = ! ( X != EN ) ;
printf ( '!(X != Y) is %d \N ' , resultaat ) ;
resultaat = ! ( X == EN ) ;
printf ( '!(X == Y) is %d \N ' , resultaat ) ;
resultaat = ! ( X > EN ) ;
printf ( '!(X > Y) is %d \N ' , resultaat ) ;
opbrengst 0 ;
}
6: Voorwaardelijke operatoren
De voorwaardelijke operator in C is ook bekend als de ternaire operator omdat er drie operanden nodig zijn: de voorwaarde, bewering 1 en bewering 2. Het evalueert de voorwaarde en retourneert bewering 1 of bewering 2, afhankelijk van het resultaat van een bepaalde voorwaarde die waar of onwaar kan zijn
Voorwaarde ? Stelling 1 : Stelling 2- Voorwaarde: Een Booleaanse expressie die controleert of deze waar of onwaar is.
- Verklaring 1: Een uitdrukking die wordt geëvalueerd als de voorwaarde waar is.
- Verklaring 2: Een uitdrukking die wordt geëvalueerd als de voorwaarde onwaar is.
Voorbeeld
In het onderstaande voorbeeld heb ik de waarde aan het getal toegewezen en vervolgens de voorwaarde toegepast. Als de voorwaarde waar is, is bewering 1 de uitvoer en als de voorwaarde onwaar is, is bewering twee de uitvoer:
#includeint voornaamst ( )
{
int nummer = 10 ;
( nummer < twintig ) ? ( printf ( 'Het is minder dan nummer 20!' ) ) : ( printf ( 'Het is groter dan nummer 20!' ) ) ;
opbrengst 0 ;
}
7: Bitsgewijze operatoren
Bitsgewijze operatoren in C manipuleren gegevens op bitniveau, wat betekent dat ze werken op individuele bits binnen gegevenstypen zoals gehele getallen. Ze kunnen niet worden toegepast op de double en float en worden gebruikt om de bits te testen en naar rechts of links te verschuiven.
Bitsgewijze operatoren in C-programmering worden gegeven in de onderstaande tabel:
| Exploitanten | Functie |
| & | Bitsgewijze EN |
| | | Bitsgewijze OF |
| ^ | Bitsgewijze exclusieve OR |
| << | Schakel naar links |
| >> | Schuif naar rechts |
| ~ | Iemands aanvulling |
Voorbeeld
Het volgende voorbeeld toont een C-programma dat bitsgewijze operatoren gebruikt:
#includeint voornaamst ( ) {
int A = 13 ; // binair 1101
int B = 7 ; // binair 0111
int resultaat ;
// Bitsgewijze EN
resultaat = A & B ; // 1101 & 0111 = 0101 (decimaal 5)
printf ( 'a & b = %u \N ' , resultaat ) ;
// Bitsgewijze OF
resultaat = A | B ; // 1101 | 0111 = 1111 (decimaal 15)
printf ( 'a | b = %u \N ' , resultaat ) ;
// Bitsgewijze XOR
resultaat = A ^ B ; // 1101 ^ 0111 = 1010 (decimaal 10)
printf ( 'a ^ b = %u \N ' , resultaat ) ;
// Bitsgewijs naar links verschuiven
resultaat = A << 2 ; // 1101 << 2 = 110100 (decimaal 52)
printf ( 'a << 2 = %u \N ' , resultaat ) ;
// Bitsgewijs naar rechts verschuiven
resultaat = A >> 2 ; // 1101 >> 2 = 0011 (decimaal 3)
printf ( 'a >> 2 = %u \N ' , resultaat ) ;
// Bitsgewijze NIET
resultaat = ~ een ; // ~1101 = 0010 (decimale 2-complementweergave van -14)
printf ( '~a = %d \N ' , resultaat ) ;
opbrengst 0 ;
}
Opmerking: Bitsgewijze operatoren worden gebruikt om taken op bitniveau uit te voeren, wat betekent dat ze werken op individuele bits binnen een binair getal. Booleaanse operatoren daarentegen worden gebruikt om bewerkingen op logische waarden uit te voeren. Ze werken op Booleaanse waarden (waar/onwaar of 1/0) en worden vaak gebruikt in besluitvormingsprocessen of voorwaardelijke verklaringen.
Het komt erop neer
Een operator is een symbool dat de compiler instrueert om bepaalde functies uit te voeren. De C-taal heeft verschillende ingebouwde operatoren, waaronder rekenkundig, unair, toewijzing, logisch, relationeel, voorwaardelijk, Booleaans en bitsgewijze. We hebben ze in detail besproken en gedemonstreerd met de voorbeelduitvoer. Lees het bovenstaande gedeelte van de gids voor gedetailleerde informatie over deze operators.