V tomto podrobném průvodci probereme operátory v programování C a jejich typy.
Operátory a jejich typy v programování C
Operátory jsou symboly, které se používají k provádění konkrétních matematických úloh. Používají se k manipulaci s daty a proměnnými. Níže jsou uvedeny různé typy operátorů v programování C:
- Aritmetické operátory
- Unární operátoři
- Operátoři přiřazení
- Logické nebo booleovské operátory
- Relační operátoři
- Podmíněné operátory
- Bitové operátory
1: Aritmetické operátory
Jedná se o operátory používané k provádění základních matematických funkcí, jako je sčítání, odčítání nebo násobení. Tyto operátory můžete použít na téměř všech vestavěných datových typech programování v jazyce C. Níže jsou uvedeny aritmetické operátory používané v programování v jazyce C:
| Operátoři | Funkce |
| + | Přidejte 2 operandy |
| – | Odečtěte 2 operandy |
| * | Vynásobte 2 operandy |
| / | Rozdělte 2 operandy |
| % | Operátor modulu udává zbytek dělení |
Příklad
V níže uvedeném příkladu jsme provedli výše uvedené aritmetické operace s proměnnou X a proměnnou Y. Proměnná X má hodnotu 20 a Y má hodnotu 5:
#include
int hlavní ( )
{
int X = dvacet ;
int A = 5 ;
int výsledek ;
výsledek = X + A ;
printf ( 'Sčítání X a Y je: %d \n ' , výsledek ) ;
výsledek = X - A ;
printf ( 'Odčítání X a Y je: %d \n ' , výsledek ) ;
výsledek = X * A ;
printf ( 'Násobení X a Y je: %d \n ' , výsledek ) ;
výsledek = X / A ;
printf ( 'Dělení X a Y je: %d \n ' , výsledek ) ;
výsledek = X % A ;
printf ( 'Dělení modulu X a Y je: %d \n ' , výsledek ) ;
vrátit se 0 ;
}
2: Unární operátory
Existují dva jedinečné unární operátory, které jsou podporovány pouze jazykem C, increment ++ a decrement — operátory. Operátor inkrementace přidá 1 k operandu a operátor dekrementace odečte 1 od operandu.
Operátor přírůstku je zapsán takto:
++ a nebo a ++
Operátor dekrementu je:
-- a nebo a --Pokud použijeme operátor inkrementace a dekrementace jako předponu, nejprve přičte nebo odečte hodnotu proměnné a pak se výsledek přiřadí proměnné vlevo. Pokud jsou operátory přidány dříve, vrátí nejprve původní hodnotu a poté se operand přičte nebo odečte o 1.
Příklad
Níže jsme přiřadili hodnoty dvěma proměnným a a b a aplikovali na ně operátory inkrementace a dekrementace:
#includeint hlavní ( )
{
int A = patnáct , b = 10 ;
printf ( '++a = %d \n ' , ++ A ) ;
printf ( 'a++ = %d.' \n ' , A ++ ) ;
vrátit se 0 ;
}
3: Operátor přiřazení
An operátor přiřazení (=) se používá pro přiřazení hodnoty proměnné v programu. Níže jsou zmíněné operátory přiřazení:
| Operátoři | Funkce |
| = | Přiřaďte hodnoty k operandu |
| += | Přidejte hodnotu operandu přítomného vpravo k levému operandu |
| -= | Odečtěte hodnotu pravého operandu od levého operandu |
| *= | Vynásobte hodnotu pravého operandu levým operandem |
| /= | Vydělte hodnotu pravého operandu levým operandem |
| %= | Vezměte modul dvou hodnot a přiřaďte hodnotu levému operandu |
Příklad
Na následujícím příkladu jsme demonstrovali fungování operátorů přiřazení na dvou operandech X a Y:
#includeint hlavní ( )
{
int X = 10 ;
int výsledek ;
výsledek = X ;
printf ( 'Hodnota výsledku = %d \n ' , výsledek ) ;
výsledek += X ;
printf ( 'Hodnota výsledku = %d \n ' , výsledek ) ;
výsledek -= X ;
printf ( 'Hodnota výsledku = %d \n ' , výsledek ) ;
výsledek *= X ;
printf ( 'Hodnota výsledku = %d \n ' , výsledek ) ;
výsledek /= X ;
printf ( 'Hodnota výsledku = %d \n ' , výsledek ) ;
vrátit se 0 ;
}
4: Relační operátory
Relační operátory se používají v programování C ke kontrole vztahu mezi dvěma proměnnými. Lze jej použít k porovnání cen položek nebo věku dvou osob. Níže jsou uvedeny relační operátory používané v programování C:
| Operátoři | Funkce |
| == | Rovná |
| > | Větší než |
| < | Méně než |
| >= | Větší než rovno |
| <= | Méně než rovno |
| != | Nerovná se |
Příklad
Níže uvedený příklad ukazuje fungování relačních operátorů v programování C:
#includeint hlavní ( )
{
int A = 9 ;
int b = 10 ;
printf ( '%d == %d je %d.' \n ' , A , b , A == b ) ;
printf ( '%d > %d je %d.' \n ' , A , b , A > b ) ;
printf ( '%d < %d je %d.' \n ' , A , b , A < b ) ;
printf ( '%d != %d je %d.' \n ' , A , b , A != b ) ;
printf ( '%d >= %d je %d.' \n ' , A , b , A >= b ) ;
printf ( '%d <= %d je %d.' \n ' , A , b , A <= b ) ;
vrátit se 0 ;
}
5: Logické operátory
Jazyk C podporuje čtyři logické operátory:
| Operátoři | Funkce |
| Logické AND (&&) | Pravda, pouze pokud jsou splněny všechny podmínky |
| Logické NEBO (||) | Pokud je splněna pouze jedna podmínka, výsledek je pravdivý |
| Logické NE(!) | Pokud je operand 0, výsledek je pravdivý |
| Bitově NE (~). | Invertuje všechny bity operandu |
Příklad
Níže uvedený příklad kódu vysvětluje fungování logických operátorů v C:
#includeint hlavní ( )
{
int X = 10 , A = 4 , S = 10 , výsledek ;
výsledek = ( X == A ) && ( S > A ) ;
printf ( '(X == Y) && (Z > Y) je %d \n ' , výsledek ) ;
výsledek = ( X == A ) && ( S < A ) ;
printf ( '(X == Y) && (Z < Y) je %d \n ' , výsledek ) ;
výsledek = ( X == A ) || ( S < A ) ;
printf ( '(X == Y) || (Z < Y) je %d \n ' , výsledek ) ;
výsledek = ( X != A ) || ( S < A ) ;
printf ( '(X != Y) || (Z < Y) je %d \n ' , výsledek ) ;
výsledek = ! ( X != A ) ;
printf ( '!(X != Y) je %d \n ' , výsledek ) ;
výsledek = ! ( X == A ) ;
printf ( '!(X == Y) je %d \n ' , výsledek ) ;
výsledek = ! ( X > A ) ;
printf ( '!(X > Y) je %d \n ' , výsledek ) ;
vrátit se 0 ;
}
6: Podmíněné operátory
Podmíněný operátor v C je také známý jako ternární operátor protože potřebuje tři operandy – podmínku, příkaz 1 a příkaz 2. Vyhodnotí podmínku a vrátí buď příkaz 1 nebo příkaz 2, v závislosti na výsledku dané podmínky, který může být buď pravdivý nebo nepravdivý
Stav ? Prohlášení 1 : Prohlášení 2- Stav: Booleovský výraz, který kontroluje, zda je pravdivý nebo nepravdivý.
- Prohlášení 1: Výraz, který je vyhodnocen, pokud je podmínka pravdivá.
- Prohlášení 2: Výraz, který je vyhodnocen, pokud je podmínka nepravdivá.
Příklad
V níže uvedeném příkladu jsem přiřadil hodnotu číslu a poté aplikoval podmínku, pokud je podmínka pravdivá, výstupem bude příkaz 1 a pokud je podmínka nepravdivá, výstupem bude příkaz dva:
#includeint hlavní ( )
{
int číslo = 10 ;
( číslo < dvacet ) ? ( printf ( 'Je to menší než číslo 20!' ) ) : ( printf ( 'Je větší než číslo 20!' ) ) ;
vrátit se 0 ;
}
7: Bitové operátory
Bitové operátory v C manipulují s daty na úrovni bitů, což znamená, že pracují s jednotlivými bity v rámci datových typů, jako jsou celá čísla. Nelze je aplikovat na double a float a používají se pro testování bitů a jejich posun doprava nebo doleva.
Bitové operátory v programování C jsou uvedeny v tabulce níže:
| Operátoři | Funkce |
| & | Bitové AND |
| | | Bitově NEBO |
| ^ | Bitwise Exclusive OR |
| << | Shift doleva |
| >> | Shift vpravo |
| ~ | Jeden doplněk |
Příklad
Následující příklad ukazuje program C, který používá bitové operátory:
#includeint hlavní ( ) {
int A = 13 ; // binární 1101
int b = 7 ; // binární 0111
int výsledek ;
// Bitové AND
výsledek = A & b ; // 1101 & 0111 = 0101 (desítkové 5)
printf ( 'a & b = %u.' \n ' , výsledek ) ;
// Bitově NEBO
výsledek = A | b ; // 1101 | 0111 = 1111 (desítkové 15)
printf ( 'a | b = %u \n ' , výsledek ) ;
// Bitový XOR
výsledek = A ^ b ; // 1101 ^ 0111 = 1010 (desetinně 10)
printf ( 'a ^ b = %u \n ' , výsledek ) ;
// Bitový posun doleva
výsledek = A << 2 ; // 1101 << 2 = 110100 (52 v desítkové soustavě)
printf ( 'a << 2 = %u \n ' , výsledek ) ;
// Bitový posun doprava
výsledek = A >> 2 ; // 1101 >> 2 = 0011 (desítkové 3)
printf ( 'a >> 2 = %u \n ' , výsledek ) ;
// Bitově NE
výsledek = ~a ; // ~1101 = 0010 (desetinný dvojkový doplněk -14)
printf ( '~a = %d \n ' , výsledek ) ;
vrátit se 0 ;
}
Poznámka: Bitové operátory se používají k provádění úloh na úrovni bitů, což znamená, že pracují s jednotlivými bity v rámci binárního čísla. Na druhé straně booleovské operátory se používají k provádění operací s logickými hodnotami. Fungují na booleovských hodnotách (true/false nebo 1/0) a běžně se používají v rozhodovacích procesech nebo podmíněných příkazech.
Sečteno a podtrženo
Operátor je symbol, který instruuje kompilátor, aby provedl určité funkce. Jazyk C má několik vestavěných operátorů včetně aritmetických, unárních, přiřazení, logických, relačních, podmíněných, booleovských a bitových. Podrobně jsme je probrali a demonstrovali na příkladu výstupu. Přečtěte si výše uvedenou část průvodce, kde najdete podrobné informace o těchto operátorech.