Časová náročnost: 2 minuty

S pomocí operátorů vytváříme výrazy. Zapíšeme-li například v matematice a + b hovoříme výrazu. Ten má dva operandy a a b a jeden operátor +.

S operandy v jazyce C to není jednoduché. Mohou být tvořeny konstantami, identifikátory objektů, řetězci a voláním funkcí. Operandy však můžeme vytvářet i pomocí kombinací zmíněných možností a dalších operátorů i závorek.

Časová náročnost: 7 minut

Přiřazovací příkaz je nejčastěji používaným příkazem ve většině programovacích jazyků. Operátorem přiřazení v jazyce C je symbol =. Obecně musíme říci, že vlevo od = musí být výraz, odkazující se do paměti. Možná to zní nejasně, ale je jisté, že hodnotu zprava musíme někam zapsat. A kam jinam ji může program zapsat, než do paměti na adresu, kterou určí právě z levé strany přiřazovacího výrazu.

Adresu proměnné určí překladač jazyka C velmi snadno. Typ výrazu je určen typem operandů. Jsou-li operandy stejného typu, je výsledek téhož typu. Jinak je typu největšího z uvedených operandů.

	Příklad:
	j = 5; d = 'z'; f = f + 3.14 *i;

Protože přiřazení je výraz je možné několikanásobné přiřazení.

	Příklad:
	int i,j,k; i = j = k = 2;

Teorie zavedla pro pravou stranu přiřazení pojmenování hodnotový výraz, zatímco stranu levou pojmenovává adresový výraz. V anglické terminologii i v některých českých textech se používá zkrácené označení rvalue - r-hodnota, respektive lvalue - l-hodnota.

Platí tedy:

Časté chyby:

ISO norma jazyka C dále důrazně nedoporučuje používat výrazy, kde se vlevo i vpravo od operátoru přiřazení mění stejná hodnota.

	Příklad:
	i = i++ *2; /* takto NE */

Časová náročnost: 7 minut

Aritmetické výrazy konstruujeme z operandů a aritmetických operátorů.

Tabulka 4.1. Operátor Činnost + sčítání - odčítání * násobení % zbytek po celočíselném dělení

Příklad 4.1.

/****************************** * op_ari_1.c * 19.03.2002 ******************************/ #include <stdio.h> int main(void) { int a = 7, b = 2; printf("cislo a = %d, cislo b = %d\n", a, b); printf("soucet %d + %d = %d\n", a, b, a+b); printf("rozdil %d - %d = %d\n", a, b, a-b); printf("soucin %d * %d = %d\n", a, b, a*b); printf("podil %d / %d = %d\n", a, b, a/b); printf("zbytek po celociselnem deleni %d %% %d = %d", a, b, a%b); return 0; }

Zkusme si ještě jeden příklad, kde argumenty aritmetických operací jsou celočíselné a levá strana je racionální.

	Příklad 4.2.
	/****************************** * op_ari_2.c * 19.03.2002 ******************************/ #include <stdio.h> int main(void) { int i, j; float r, x; i = j = 5; j *= i; r = j / 3; x = j * 3; printf("i=%d\tj=%d\tr=%f\tx=%f\n", i, j, r, x); return 0; }

V tomto příkladu jasně vidíme, že výpočet na pravé straně probíhá podle typů operandů pravé strany. Teprve je-li to potřeba je výsledek převeden na typ odpovídajíc straně levé.

Proto je výsledek tohoto příkladu: i=5 j=25 r=8.000000 x=75.000000

Pro určení pořadí vyhodnocování jednotlivých částí výrazů používáme kulaté závorky ().

Časová náročnost: 5 minut

Logické hodnoty jsou dva, pravda a nepravda. Norma ISO C říká, že hodnota nepravda je představována nulou, zatímco pravda jedničkou. V případě hodnoty pravda se ovšem jedná pouze o doporučení. Neboť užívaným anachronismem je považovat jakoukoliv nenulovou hodnotu za pravdu.

Tabulka 4.2. Operátor Činnost & and (logický součet) || or (logický součin) ! not (negace)

Pravidla pro určení výsledku známe z Booleovy algebry.

Pro demonstrování funkcí AND, OR a NOT si napíšeme jednoduchý příklad.

	Příklad 4.3.
	/****************************** * op_lg.c * 19.03.2002 ******************************/ #include <stdio.h> int main(void) { int p,q; printf("Zadejte P (0 nebo 1): "); scanf("%d",&p); printf("Zadejte Q (0 nebo 1): "); scanf("%d",&q); printf("P AND Q: %d\n", p && q); printf("P OR Q: %d\n", p ¦¦ q); printf("NOT Q: %d\n", !q); return 0; }

Časová náročnost: 3 minuty

Máme následující relační operátory:

Tabulka 4.3. Operátor Činnost < menší > větší <= menší nebo rovno >= větší nebo rovno == rovno != nerovno

Tyto operátory jsou definovány pro operandy všech základních datových typů. Ovšem například pro ukazatele mají smysl pouze operátory rovnosti a nerovnosti. Výsledkem relačních operací jsou logické hodnoty pravda a nepravda.

Časová náročnost: 15 minut

Již podle názvu můžeme usuzovat, že nám bitové operátory umožňují provádět operace nad jednotlivými bity. Bitové operace je však možné provádět pouze s celočíselnými hodnotami.

Máme následující typy bitových operátorů:

Tabulka 4.4. Operátor Činnost << bitový posun vlevo >> bitový posun vpravo & bitový and (logický součin, konjunkce) | bitový or (logický součet, disjunkce) ^ bitový not (negace, inverze) ~ bitový xor (nonekvivalence)

Při bitovém posunu vlevo (vpravo) << (>>), se jednotlivé bity posouvají vlevo (vpravo), tedy do pozice s (binárně) vyšším (nižším) řádem. Na nejpravější (nejlevější) posunem vytvořenou pozici je umístěna nula. Posuny ovšem probíhají aritmeticky. To znamená, že uvedené pravidlo neplatí pro posun vpravo hodnoty celočíselného typu se znaménkem. V takovém případě se nejvyšší bit (znaménkový), zachovává. Takto se při posunu doplňuje do bitového řetězce nový bit. Naopak před posunem nejlevější (nejpravější) bit je odeslán do říše zapomnění.

Bitový posun o jeden (binární) řád vpravo, respektive vlevo, má stejný význam, jako celočíselné dělení, respektive násobení, dvěma. Je-li bitový posun o více než jeden řád, jedná se o násobení (dělení) příslušnou mocninou dvou. Přirozeně to platí pouze pro bitový posun celočíselných typů unsigned.

Obecný formát pro operátory bitového posunu vlevo (vpravo):

hodnota << počet-bitů	   	 
hodnota >> počet-bitů

Bitové and &, or |, a xor ^ provádí příslušnou binární operaci s každým párem odpovídajících si bitů. Výsledek je umístěn do pozice stejného binárního řádu výsledku. Výsledky operací nad jednotlivými bity jsou stejné, jako v Booleově algebře. Bitové not ~ je operátorem unárním, provádí negaci každého bitu v bitovém řetězci jediného operandu. Tomuto operátoru se často říká bitový doplněk.

	Pozn:
	XOR dává výsledek jedna jen v případě různosti hodnot operandů.

Nyní si ukážeme jednoduchý příklad použití bitových posunů.

Příklad 4.4.

/****************************** * op_bit.c * 19.03.2002 ******************************/ #include <stdio.h> int main() { printf("1 << 1 = \t%d\t%#x\n", 1 << 1, 1 << 1); printf("1 << 7 = \t%d\t%#x\n", 1 << 7, 1 << 7); printf("-1 >> 1 = \t%d\t%#x\n", -1 >> 1, -1 >> 1); printf("512 >> 8 = \t%d\t%#x\n", 512 >> 8, 512 >> 8); printf("2 & 1 = \t%d\t%#x\n", 2 & 1, 2 & 1); printf("2 | 1 = \t%d\t%#x\n", 2 | 1, 2 | 1); printf("2 ^ 1 = \t%d\t%#x\n", 2 ^ 1, 2 ^ 1); return 0; }

Výsledkem tohoto programu je následující výpis:

1 << 1 =        2       0x2
1 << 7 =        128     0x80
-1 >> 1 =       -1      0xffffffff
512 >> 8 =      2       0x2
2 & 1 =         0       0
2 | 1 =         3       0x3
2 ^ 1 =         3       0x3

Operace XOR má jednu zajímavou vlastnost. Máme-li dvě hodnoty A a B, pak je-li na výsledek operace A XOR B uplatněna znovu operace XOR s operandem B dostáváme operand A. Tuto vlastnost si demonstrujeme na příkladu.

	Příklad 4.5.
	/****************************** * op_lgxor.c * 19.03.2002 ******************************/ #include <stdio.h> int main (void) { int a = 10, b = 20; printf("Pocatecni hodnota a: %d\n",a); a = a ^ b; printf("Po prvnim XOR: %d\n",a); a = a ^ b; printf("Po druhem XOR: %d\n",a); return 0; }

Časová náročnost: 2 minuty

Adresový operátor & je unární. Jak již název adresový operátor napovídá, umožňuje získat adresu objektu, na nějž je aplikován. Adresu objektu můžeme použít v nejrůznějších situacích, obvykle je to v souvislosti s předáváním výsledků funkcí. Takto například můžeme přečíst hodnoty dvou proměnných jedinou funkcí pro formátovaný vstup.

	Příklad:
	int i; float f; scanf("%d %f",&i, &f);

Časová náročnost: 8 minut

Jazyk C obsahuje ternární (trojitý) operátor ?. Ternární operátor potřebuje tři operandy. Operátor ? se používá pro náhradu příkazu typu:

if(podmínka) příkaz1;
else příkaz2;

Obecný formát operátoru ? je:

proměnná = podmínka ? výraz1 : výraz2

	Flashová animace
	Kliknutím na ikonu spustíte test.

Podmínka je výraz, který je vyhodnocen jako pravdivý nebo nepravdivý. Je-li pravdivý dosadí se do proměnné hodnota výrazu1. Je-li nepravdivý, dosadí se do proměnné hodnota výrazu2. Důvodem použití operátoru ? je to, že překladač jazyka C může v tomto případě vytvářet mnohem efektivnější kód než při použití příkazu if-else.

Ukažme si použití podmíněného operátoru na příkladu. Mějme program, který načte číslo a v případě že je větší nebo rovno nule jej převede na jedničku a v případě, že zadané číslo bylo záporné, na mínus jedničku.

	Příklad 4.6.
	/****************************** * op_condi.c * 19.03.2002 ******************************/ #include <stdio.h> int main(void) { int i; printf("Zadejte cislo: "); scanf("%d",&i); i = i>=0 ? 1: -1; printf("Vysledek: %d",i); return 0; }

Časová náročnost: 5 minut

Operátor čárka má zcela jedinečnou funkci. Říká překladači udělej tohle a tohle a tohle. To znamená, že se čárka používá pro zřetězení několika operací.

V následujícím cyklu se čárka používá v inicializační části pro inicializaci dvou řídících proměnných cyklu a v části pro inkrementaci i a j.

	Pozn:
	O cyklu for si více řekneme v následující kapitole.

	Příklad:
	for(i=0, j=0; i+j<pocet; i++, j++) .......

Hodnotu seznamu výrazů oddělených čárkami určuje výraz, který stojí nejvíce vpravo. V následujícím příkladu se do proměnné hodnota přiřadí číslo 100.

	Příklad:
	hodnota = (pocet, 90, 50, 100);

Závorky jsou zde potřebné, neboť operátor čárka má nižší prioritu než přiřazovací operátor.

Časová náročnost: 5 minut

Někdy potřebujeme dočasně změnit typ proměnné. Můžeme například chtít používat pro nějaký výpočet hodnotu v pohyblivé řádové čárce, ale někde pro ni chceme zase použít operátor celočíselného dělení. Jelikož však lze tento operátor použít pouze na celá čísla máme problém. Jedním z možných řešení je vytvořit celočíselnou proměnnou, která se bude používat pro celočíselné dělení a ve vhodné chvíli ji přiřadit hodnotu proměnné s pohyblivou řádovou čárkou. To je však poněkud neelegantní řešení. Jiným řešení je použít přetypování, které způsobí dočasnou změnu typu.

Přetypování má obecný tvar:

(typ) hodnota

kde typ je jméno platného typu jazyka C.

	Příklad:
	float f; f = 100.2; printf("%d", (int) f); /* přetypování na celé číslo */

Časová náročnost: 5 minut

Následující přehled všech operátorů ukazuje jejich prioritu od nejvyšší po nejnižší.

Tabulka 4.5. Operátory Asociativita ( ) [ ] ->. zleva doprava ! ~ + - ++ -- (přetypování) *(pointer) &(adresní operátor) sizeof zprava doleva * / % zleva doprava + - zleva doprava << >> zleva doprava < <= > >= zleva doprava == != zleva doprava & zleva doprava ^ zleva doprava | zleva doprava && zleva doprava || zleva doprava ?: zprava doleva = += -= *= /= %= >>= <<= &= |= ^= zprava doleva , zleva doprava