Tässä yksityiskohtaisessa oppaassa käsittelemme C-ohjelmoinnin operaattoreita ja niiden tyyppejä.
Operaattorit ja niiden tyypit C-ohjelmoinnissa
Operaattorit ovat symboleja, joita käytetään tiettyjen matemaattisten tehtävien suorittamiseen. Niitä käytetään tietojen ja muuttujien manipulointiin. Seuraavat ovat erityyppiset operaattorit C-ohjelmoinnissa:
- Aritmeettiset operaattorit
- Yksittäiset operaattorit
- Tehtäväoperaattorit
- Loogiset tai Boolen operaattorit
- Relaatiooperaattorit
- Ehdolliset operaattorit
- Bittikohtaiset operaattorit
1: Aritmeettiset operaattorit
Nämä ovat operaattoreita, joita käytetään suorittamaan matemaattisia perustoimintoja, kuten yhteenlasku, vähennyslasku tai kertolasku. Voit käyttää näitä operaattoreita lähes kaikissa C-ohjelmoinnin sisäänrakennetuissa tietotyypeissä. Seuraavat ovat C-ohjelmoinnissa käytetyt aritmeettiset operaattorit:
| Operaattorit | Toiminnot |
| + | Lisää 2 operandia |
| – | Vähennä 2 operandia |
| * | Kerro 2 operandia |
| / | Jaa 2 operandia |
| % | Moduulioperaattori antaa lopun jaosta |
Esimerkki
Alla olevassa esimerkissä olemme suorittaneet edellä mainitut aritmeettiset operaatiot muuttujalle X ja muuttujalle Y. Muuttujalla X on arvo 20 ja Y:llä on arvo 5:
#include
int pää ( )
{
int X = kaksikymmentä ;
int JA = 5 ;
int tulos ;
tulos = X + JA ;
printf ( 'X:n ja Y:n lisäys on: %d \n ' , tulos ) ;
tulos = X - JA ;
printf ( 'X:n ja Y:n vähennys on: %d \n ' , tulos ) ;
tulos = X * JA ;
printf ( 'X:n ja Y:n kertolasku on: %d \n ' , tulos ) ;
tulos = X / JA ;
printf ( 'X:n ja Y:n jako on: %d \n ' , tulos ) ;
tulos = X % JA ;
printf ( 'X:n ja Y:n moduulijako on: %d \n ' , tulos ) ;
palata 0 ;
}
2: Yksittäiset operaattorit
On olemassa kaksi ainutlaatuista unaarioperaattoria, joita vain C-kieli tukee, increment ++ ja decrement -operaattorit. Lisäysoperaattori lisää operandiin 1:n ja vähennysoperaattori vähentää 1:n operandista.
Kasvuoperaattori kirjoitetaan seuraavasti:
++ a tai a ++
Vähennysoperaattori on:
-- a tai a --Jos käytämme etuliitteenä lisäys- ja vähennysoperaattoria, se ensin lisää tai vähentää muuttujan arvon ja sitten tulos liitetään vasemmalla olevaan muuttujaan. Jos operaattorit lisätään ennen, se palauttaa ensin alkuperäisen arvon ja sitten operandi lisätään tai vähennetään 1:llä.
Esimerkki
Alla olemme määrittäneet arvot kahdelle muuttujalle a ja b ja käyttäneet niihin lisäys- ja vähennysoperaattoreita:
#includeint pää ( )
{
int a = viisitoista , b = 10 ;
printf ( '++a = %d \n ' , ++ a ) ;
printf ( 'a++ = %d \n ' , a ++ ) ;
palata 0 ;
}
3: Tehtäväoperaattori
An tehtäväoperaattori (=) käytetään arvon määrittämiseen ohjelman muuttujalle. Alla mainitut toimeksiantooperaattorit:
| Operaattorit | Toiminto |
| = | Anna arvot operandille |
| += | Lisää oikealla olevan operandin arvo vasempaan operandiin |
| -= | Vähennä oikean operaandin arvo vasemmasta operaandista |
| *= | Kerro oikean operandin arvo vasemmalle operandille |
| /= | Jaa oikean operandin arvo vasemmalle |
| %= | Ota kahden arvon moduuli ja anna arvo vasemmalle operandille |
Esimerkki
Olemme osoittaneet osoitusoperaattorien toiminnan kahdella operandilla X ja Y alla olevassa esimerkissä:
#includeint pää ( )
{
int X = 10 ;
int tulos ;
tulos = X ;
printf ( 'Tuloksen arvo = %d \n ' , tulos ) ;
tulos += X ;
printf ( 'Tuloksen arvo = %d \n ' , tulos ) ;
tulos -= X ;
printf ( 'Tuloksen arvo = %d \n ' , tulos ) ;
tulos *= X ;
printf ( 'Tuloksen arvo = %d \n ' , tulos ) ;
tulos /= X ;
printf ( 'Tuloksen arvo = %d \n ' , tulos ) ;
palata 0 ;
}
4: Relaatiooperaattorit
Relaatiooperaattoreita käytetään C-ohjelmoinnissa kahden muuttujan välisen suhteen tarkistamiseen. Sen avulla voidaan vertailla tuotteiden hintoja tai kahden henkilön ikää. Seuraavat ovat C-ohjelmoinnissa käytetyt relaatiooperaattorit:
| Operaattorit | Toiminnot |
| == | Yhtä kuin |
| > | Suurempi kuin |
| < | Vähemmän kuin |
| >= | Suurempi kuin yhtä suuri |
| <= | Vähemmän kuin yhtä suuri kuin |
| != | Ei yhtä suuri kuin |
Esimerkki
Alla oleva esimerkki näyttää relaatiooperaattorien toiminnan C-ohjelmoinnissa:
#includeint pää ( )
{
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 ) ;
palata 0 ;
}
5: Loogiset operaattorit
On olemassa neljä loogista operaattoria, joita C-kieli tukee:
| Operaattorit | Toiminto |
| Looginen JA (&&) | Totta vain, jos kaikki ehdot täyttyvät |
| Looginen TAI (||) | Jos vain yksi ehto täyttyy, tulos on tosi |
| Looginen EI(!) | Jos Operandi on 0, tulos on tosi |
| Bittikohtaisesti EI (~). | Kääntää kaikki operandin bitit |
Esimerkki
Alla oleva esimerkkikoodi selittää loogisten operaattoreiden toiminnan C:ssä:
#includeint pää ( )
{
int X = 10 , JA = 4 , KANSSA = 10 , tulos ;
tulos = ( X == JA ) && ( KANSSA > JA ) ;
printf ( '(X == Y) && (Z > Y) on %d \n ' , tulos ) ;
tulos = ( X == JA ) && ( KANSSA < JA ) ;
printf ( '(X == Y) && (Z < Y) on %d \n ' , tulos ) ;
tulos = ( X == JA ) || ( KANSSA < JA ) ;
printf ( '(X == Y) || (Z < Y) on %d \n ' , tulos ) ;
tulos = ( X != JA ) || ( KANSSA < JA ) ;
printf ( '(X != Y) || (Z < Y) on %d \n ' , tulos ) ;
tulos = ! ( X != JA ) ;
printf ( '!(X != Y) on %d \n ' , tulos ) ;
tulos = ! ( X == JA ) ;
printf ( '!(X == Y) on %d \n ' , tulos ) ;
tulos = ! ( X > JA ) ;
printf ( '!(X > Y) on %d \n ' , tulos ) ;
palata 0 ;
}
6: Ehdolliset operaattorit
C:n ehdollinen operaattori tunnetaan myös nimellä the kolmiosainen operaattori koska se vaatii kolme operandia – ehdon, lauseen 1 ja lauseen 2. Se arvioi ehdon ja palauttaa joko lauseen 1 tai lauseen 2 riippuen tietyn ehdon tuloksesta, joka voi olla joko tosi tai epätosi
Kunto ? lausunto 1 : lausunto 2- Kunto: Boolen lauseke, joka tarkistaa, onko se tosi tai epätosi.
- Lausuma 1: Lauseke, joka arvioidaan, jos ehto on tosi.
- Lausuma 2: Lauseke, joka arvioidaan, jos ehto on epätosi.
Esimerkki
Alla olevassa esimerkissä olen määrittänyt arvon numerolle ja soveltanut sitten ehtoa, jos ehto on tosi, tulos on lause 1 ja jos ehto on epätosi, tulos on lause kaksi:
#includeint pää ( )
{
int määrä = 10 ;
( määrä < kaksikymmentä ) ? ( printf ( 'Se on vähemmän kuin numero 20!' ) ) : ( printf ( 'Se on suurempi kuin numero 20!' ) ) ;
palata 0 ;
}
7: Bittioperaattorit
Bittikohtaiset operaattorit C:ssä käsittelevät dataa bittitasolla, mikä tarkoittaa, että ne toimivat yksittäisillä biteillä tietotyypeissä, kuten kokonaislukuina. Niitä ei voi soveltaa kaksois- ja kellukkeeseen, ja niitä käytetään bittien testaamiseen ja niiden siirtämiseen oikealle tai vasemmalle.
C-ohjelmoinnin bittioperaattorit on annettu alla olevassa taulukossa:
| Operaattorit | Toiminto |
| & | Bitittain JA |
| | | Bittikohtaisesti TAI |
| ^ | Bitwise Exclusive TAI |
| << | Vaihto vasemmalle |
| >> | Vaihto oikealle |
| ~ | Yhden täydennys |
Esimerkki
Seuraava esimerkki näyttää C-ohjelman, joka käyttää bittikohtaisia operaattoreita:
#includeint pää ( ) {
int a = 13 ; // binääri 1101
int b = 7 ; // binääri 0111
int tulos ;
// Bittikohtainen JA
tulos = a & b ; // 1101 & 0111 = 0101 (desimaali 5)
printf ( 'a & b = %u \n ' , tulos ) ;
// Bittikohtainen TAI
tulos = a | b ; // 1101 | 0111 = 1111 (desimaali 15)
printf ( 'a | b = %u \n ' , tulos ) ;
// Bittikohtainen XOR
tulos = a ^ b ; // 1101 ^ 0111 = 1010 (desimaali 10)
printf ( 'a ^ b = %u \n ' , tulos ) ;
// Bittisuuntainen siirto vasemmalle
tulos = a << 2 ; // 1101 << 2 = 110100 (desimaali 52)
printf ( 'a << 2 = %u \n ' , tulos ) ;
// Bittikohtainen siirto oikealle
tulos = a >> 2 ; // 1101 >> 2 = 0011 (desimaali 3)
printf ( 'a >> 2 = %u \n ' , tulos ) ;
// Bittikohtaisesti EI
tulos = ~a ; // ~1101 = 0010 (desimaali 2:n komplementtiesitys arvosta -14)
printf ( '~a = %d \n ' , tulos ) ;
palata 0 ;
}
Huomautus: Bittioperaattoreita käytetään suorittamaan tehtäviä bittitasolla, mikä tarkoittaa, että ne toimivat yksittäisillä biteillä binääriluvun sisällä. Boolen operaattoreita sitä vastoin käytetään suorittamaan operaatioita loogisille arvoille. Ne toimivat Boolen arvoilla (tosi/epätosi tai 1/0) ja niitä käytetään yleisesti päätöksentekoprosesseissa tai ehdollisissa lausumissa.
Bottom Line
Operaattori on symboli, joka ohjaa kääntäjää suorittamaan tiettyjä toimintoja. C-kielessä on useita sisäänrakennettuja operaattoreita, mukaan lukien aritmeettinen, unaarinen, osoitus, looginen, relaatio-, ehdollinen, Boolen ja bittikohtainen. Olemme keskustelleet niistä yksityiskohtaisesti ja osoittaneet ne esimerkkituloksella. Lue oppaan yllä oleva osa saadaksesi yksityiskohtaista tietoa näistä operaattoreista.