Selles üksikasjalikus juhendis käsitleme C-programmeerimise operaatoreid ja nende tüüpe.
Operaatorid ja nende tüübid C-programmeerimises
Operaatorid on sümbolid, mida kasutatakse konkreetsete matemaatiliste ülesannete täitmiseks. Neid kasutatakse andmete ja muutujatega manipuleerimiseks. Järgmised on C-programmeerimise eri tüüpi operaatorid:
- Aritmeetilised operaatorid
- Unaarsed operaatorid
- Määramise operaatorid
- Loogilised või Boole'i operaatorid
- Suhteoperaatorid
- Tingimuslikud operaatorid
- Bitioperaatorid
1: Aritmeetilised operaatorid
Need on operaatorid, mida kasutatakse põhiliste matemaatiliste funktsioonide (nt liitmine, lahutamine või korrutamine) täitmiseks. Saate neid operaatoreid kasutada peaaegu kõigi C-programmeerimise sisseehitatud andmetüüpide puhul. Järgmised on C-programmeerimises kasutatavad aritmeetilised operaatorid:
| Operaatorid | Funktsioonid |
| + | Lisage 2 operandi |
| – | Lahutage 2 operandi |
| * | Korrutage 2 operandit |
| / | Jagage 2 operandi |
| % | Moodulioperaator annab jaotuse ülejäänud osa |
Näide
Allolevas näites oleme teinud ülalnimetatud aritmeetilised toimingud muutujaga X ja muutuja Y. Muutuja X väärtus on 20 ja Y väärtus 5:
#include
int peamine ( )
{
int X = kakskümmend ;
int JA = 5 ;
int tulemus ;
tulemus = X + JA ;
printf ( 'X ja Y liitmine on: %d \n ' , tulemus ) ;
tulemus = X - JA ;
printf ( 'X ja Y lahutamine on %d \n ' , tulemus ) ;
tulemus = X * JA ;
printf ( 'X ja Y korrutamine on %d \n ' , tulemus ) ;
tulemus = X / JA ;
printf ( 'X ja Y jaotus on: %d \n ' , tulemus ) ;
tulemus = X % JA ;
printf ( 'X ja Y moodulite jaotus on: %d \n ' , tulemus ) ;
tagasi 0 ;
}
2: Unaarsed operaatorid
On kaks unikaalset unaarset operaatorit, mida toetab ainult C keel, increment ++ ja decrement — operaatorid. Kasvamisoperaator lisab operandile 1 ja kahandamisoperaator lahutab operandist 1.
Kasvuoperaator kirjutatakse järgmiselt:
++ a või a ++
Vähendamise operaator on:
-- a või a --Kui kasutame eesliitena operaatorit suurendamine ja vähendamine, lisab või lahutab see kõigepealt muutuja väärtuse ja seejärel määratakse tulemus vasakul olevale muutujale. Kui operaatorid on eelnevalt lisatud, tagastab see esmalt algse väärtuse ja seejärel liidetakse või lahutatakse operandi 1.
Näide
Allpool oleme määranud väärtused kahele muutujale a ja b ning rakendanud neile juurdekasvu ja kahanemise operaatoreid:
#includeint peamine ( )
{
int a = viisteist , b = 10 ;
printf ( '++a = %d \n ' , ++ a ) ;
printf ( 'a++ = %d \n ' , a ++ ) ;
tagasi 0 ;
}
3: määramise operaator
An määramise operaator (=) kasutatakse programmi muutujale väärtuse määramiseks. Allpool on mainitud määramise operaatorid:
| Operaatorid | Funktsioon |
| = | Määrake operandile väärtused |
| += | Lisage paremal oleva operandi väärtus vasakpoolsele operandile |
| -= | Lahutage vasakpoolsest operandist parempoolse operandi väärtus |
| *= | Korrutage parempoolse operandi väärtus vasakpoolse operandiga |
| /= | Jagage parempoolse operandi väärtus vasakpoolsele operandile |
| %= | Võtke kahe väärtuse moodul ja määrake väärtus vasakule operandile |
Näide
Oleme demonstreerinud määramisoperaatorite tööd kahel operandil X ja Y allolevas näites:
#includeint peamine ( )
{
int X = 10 ;
int tulemus ;
tulemus = X ;
printf ( 'Tulemuse väärtus = %d \n ' , tulemus ) ;
tulemus += X ;
printf ( 'Tulemuse väärtus = %d \n ' , tulemus ) ;
tulemus -= X ;
printf ( 'Tulemuse väärtus = %d \n ' , tulemus ) ;
tulemus *= X ;
printf ( 'Tulemuse väärtus = %d \n ' , tulemus ) ;
tulemus /= X ;
printf ( 'Tulemuse väärtus = %d \n ' , tulemus ) ;
tagasi 0 ;
}
4: suhteoperaatorid
Relatsioonioperaatoreid kasutatakse C-programmeerimises kahe muutuja vahelise seose kontrollimiseks. Sellega saab võrrelda esemete hindu või kahe inimese vanust. Järgmised on C-programmeerimises kasutatavad relatsioonioperaatorid:
| Operaatorid | Funktsioonid |
| == | Võrdne |
| > | Suurem kui |
| < | Vähem kui |
| >= | Suurem kui võrdne |
| <= | Vähem kui võrdne |
| != | Pole võrdne |
Näide
Allolev näide näitab relatsioonioperaatorite tööd C-programmeerimises:
#includeint peamine ( )
{
int a = 9 ;
int b = 10 ;
printf ( '%d == %d on %d \n ' , a , b , a == b ) ;
printf ( '%d > %d on %d \n ' , a , b , a > b ) ;
printf ( '%d < %d on %d \n ' , a , b , a < b ) ;
printf ( '%d != %d on %d \n ' , a , b , a != b ) ;
printf ( '%d >= %d on %d \n ' , a , b , a >= b ) ;
printf ( '%d <= %d on %d \n ' , a , b , a <= b ) ;
tagasi 0 ;
}
5: loogilised operaatorid
C-keel toetab nelja loogilist operaatorit:
| Operaatorid | Funktsioon |
| Loogiline JA (&&) | Tõsi ainult siis, kui kõik tingimused on täidetud |
| Loogiline VÕI (||) | Kui ainult üks tingimus on täidetud, on tulemus tõene |
| Loogiline EI(!) | Kui Operandi väärtus on 0, on tulemus tõene |
| Bitipõhiselt EI (~). | Inverteerib kõik operandi bitid |
Näide
Allolev näitekood selgitab loogiliste operaatorite tööd C-s:
#includeint peamine ( )
{
int X = 10 , JA = 4 , KOOS = 10 , tulemus ;
tulemus = ( X == JA ) && ( KOOS > JA ) ;
printf ( '(X == Y) && (Z > Y) on %d \n ' , tulemus ) ;
tulemus = ( X == JA ) && ( KOOS < JA ) ;
printf ( '(X == Y) && (Z < Y) on %d \n ' , tulemus ) ;
tulemus = ( X == JA ) || ( KOOS < JA ) ;
printf ( '(X == Y) || (Z < Y) on %d \n ' , tulemus ) ;
tulemus = ( X != JA ) || ( KOOS < JA ) ;
printf ( '(X != Y) || (Z < Y) on %d \n ' , tulemus ) ;
tulemus = ! ( X != JA ) ;
printf ( '!(X != Y) on %d \n ' , tulemus ) ;
tulemus = ! ( X == JA ) ;
printf ( '!(X == Y) on %d \n ' , tulemus ) ;
tulemus = ! ( X > JA ) ;
printf ( '!(X > Y) on %d \n ' , tulemus ) ;
tagasi 0 ;
}
6: tingimuslikud operaatorid
C tingimuslikku operaatorit tuntakse ka kui kolmekordne operaator sest selleks on vaja kolme operandi – tingimus, väide 1 ja väide 2. See hindab tingimust ja tagastab kas väite 1 või väite 2, olenevalt antud tingimuse tulemusest, mis võib olla kas tõene või väär
Seisund ? avaldus 1 : avaldus 2- Seisukord: Tõene avaldis, mis kontrollib, kas see on tõene või väär.
- Väide 1: Avaldis, mida hinnatakse, kui tingimus on tõene.
- Väide 2: Avaldis, mida hinnatakse, kui tingimus on väär.
Näide
Allolevas näites olen määranud arvule väärtuse ja seejärel rakendanud tingimust. Kui tingimus on tõene, siis väljundiks on väide 1 ja kui tingimus on väär, siis väljundiks avaldus kaks:
#includeint peamine ( )
{
int number = 10 ;
( number < kakskümmend ) ? ( printf ( 'See on vähem kui number 20!' ) ) : ( printf ( 'See on suurem kui number 20!' ) ) ;
tagasi 0 ;
}
7: Bitioperaatorid
Bitioperaatorid C-s manipuleerivad andmeid bititasandil, mis tähendab, et nad töötavad andmetüüpide, näiteks täisarvude, üksikute bittide peal. Neid ei saa rakendada topelt- ja ujukile ning neid kasutatakse bittide testimiseks ja nende paremale või vasakule nihutamiseks.
Bitioperaatorid C-programmeerimisel on toodud allolevas tabelis:
| Operaatorid | Funktsioon |
| & | Bitipõhine JA |
| | | Bitihaaval VÕI |
| ^ | Bitipõhine eksklusiivne VÕI |
| << | Nihutage vasakule |
| >> | Tõstuki paremale |
| ~ | Üks täiendus |
Näide
Järgmine näide näitab C-programmi, mis kasutab bitipõhiseid tehteid:
#includeint peamine ( ) {
int a = 13 ; // binaarne 1101
int b = 7 ; // binaarne 0111
int tulemus ;
// Bitipõhine JA
tulemus = a & b ; // 1101 & 0111 = 0101 (koma 5)
printf ( 'a & b = %u \n ' , tulemus ) ;
// Bitipõhine VÕI
tulemus = a | b ; // 1101 | 0111 = 1111 (15 kümnendkohaga)
printf ( 'a | b = %u \n ' , tulemus ) ;
// Bitipõhine XOR
tulemus = a ^ b ; // 1101 ^ 0111 = 1010 (kümnendkoht 10)
printf ( 'a ^ b = %u \n ' , tulemus ) ;
// Bitisuunaline nihe vasakule
tulemus = a << 2 ; // 1101 << 2 = 110100 (kümnendkoht 52)
printf ( 'a << 2 = %u \n ' , tulemus ) ;
// Bitisuunaline nihe paremale
tulemus = a >> 2 ; // 1101 >> 2 = 0011 (koma 3)
printf ( 'a >> 2 = %u \n ' , tulemus ) ;
// Bitipõhiselt EI
tulemus = ~a ; // ~1101 = 0010 (kümnendarvu 2 komplemendi esitus -14)
printf ( '~a = %d \n ' , tulemus ) ;
tagasi 0 ;
}
Märge: Bitioperaatoreid kasutatakse ülesannete täitmiseks bititasandil, mis tähendab, et nad töötavad kahendarvu üksikute bittide peal. Boole'i operaatoreid seevastu kasutatakse loogiliste väärtustega tehtavate toimingute tegemiseks. Need töötavad Boole'i väärtustel (tõene/väär või 1/0) ja neid kasutatakse tavaliselt otsustusprotsessides või tingimuslausetes.
Alumine joon
Operaator on sümbol, mis juhendab kompilaatorit teatud funktsioone täitma. C-keeles on mitu sisseehitatud operaatorit, sealhulgas aritmeetiline, unaarne, määramine, loogiline, relatsioon, tingimuslik, tõeväärtus ja bitipõhine operaator. Oleme neid üksikasjalikult arutanud ja näidisväljundiga demonstreerinud. Nende operaatorite kohta üksikasjaliku teabe saamiseks lugege juhendi ülaltoodud jaotist.