====== Základní operátory ======
R-hodnota (viz. dříve) se může skládat z více prvků s vlastnostmi r-hodnoty. To uděláme za pomoci nějakých operátorů, se dvěmi hodnotami můžeme provádět různé operace (aritmetické, logické a další). k tomu nám slouží různé operátory.
===== Příklad =====
int x, a, b = 2;
x = (a = (b * 2) - 3);
Na konci tohoto kódu budou proměnné "x" a "a" držet hodnotu 1.
Z toho také vyplívá, že celé přiřazení (l-hodnota = r-hodnota) je zároveň r-hodnotou a lze ho přiřadit do jiné l-hodnoty (např. proměnné).
Také si všimněme, že lze použít závorky () k seskupování výrazů a úpravě jejich priorit (víme, že násobení má přednost před sčítáním), tato základní asociativita funguje stejně jako v matematice, pokud si nejsme jisti, nemusíme experimentovat a prostě se pojistíme závorkou.
===== Přehled operátorů =====
Zde naleznete seznam různých operátorů. Některé z nich budeme používat a vysvětlíme si je, ale většinu z nich zatím potřebovat nebudeme, ale k tomuto seznamu se určitě budete potřebovat vracet.
+ sčítání
- odčítání
* násobení
/ dělení
% dělení modulo (zbytek po dělení)
++, -- inkrementace resp. dekrementace hodnoty, prefixový i postfixový zápis
= *= /= %= += -= <<= >>= &= |= ^= jednoduché přiřazení a přiřazení s výpočtem
< menší než
> větší než
<= menší nebo rovno
>= větší nebo rovno
== rovnost
!= nerovnost
&& logický součin (and)
|| logický součet (or)
! logická negace
~ bitová negace
<<, >> bitový posun vlevo resp. vpravo
& bitový součin (and)
| bitový součet (or)
^ bitový vylučovací (exkluzivní) součet (xor)
?: podmíněné vyhodnocení zprava doleva
. tečka, přímý přístup ke členu struktury
-> nepřímý přístup ke členu struktury
, čárka, oddělení výrazů
sizeof získání velikosti objektu v bytech
(typ) přetypování na typ uvedený v závorkách
& reference (získání adresy objektu)
* dereference (získání objektu dle adresy)
===== Porovnávání =====
V kapitole, kde budeme probírat podmínky a cykly určitě využijeme porovnávací operátory (<,>,<=,>=,==,!=), logickou negaci (!) a logický součin a součet (&&,||).
Pokud jde o porovnávací operátory, tak vždy vrací hodnotu true (1 nebo jiná nenulová hodnota), nebo false (0), tj. pravda/nepravda.
Logický součin (&&) vrací true pouze pokud jsou obě hodnoty true. Pokud je první hodnota false, tak se druhá nevyhodnocuje (zjednodusene vyhodnocovani).
Logický součet (||) vrací true pokud je alespoň jedna z hodnot true. Pokud je první hodnota true, tak se druhá nevyhodnocuje (zjednodusene vyhodnocovani).
Logická negace vrací opak (!1 je 0, !0 je 1).
===== Příklady =====
int a = 2, b = 3, x = 4, y = 2;
b = !(b == a); //b bude true
b = (b != a); //b bude true (jde o prakticky jiny zapis stejneho vypoctu)
b = (a = 2); //casta chyba - nedojde k porovnani, ale prirazeni 2 do a a nasledne do b
x = (x <= y); //x bude false
y = !((1 <= 2)||(b = 7)); //y bude false, prirazeni 7 do b neprobehne (pouzito zjednodusene vyhodnocovani)
y = 128; //y bude true
y = 0; //y bude false
y = !y; //y bude true
===== Inkrementace, dekrementace,... =====
Hodnotu proměnné můžeme změnit i jiným způsobem, než je přiřazení:
int a = 31, b;
a++; //a bude zvětšena o 1 (jiný zápis: a = a+1; )
a *= 2; //a bude vynásobeno 2 (jiný zápis: a = a*2; )
b = a++; //a bude přiřazeno do b a následně zvětšeno o 1
b = --a; //a bude zmenšeno o 1 a nasledne prirazeno do b
===== Operátor sizeof() =====
sizeof je makro preprocesoru, které nám vrátí velikost daného datového typu (viz. kapitola jednoduché datové typy) v bytech. Víme, že například celé číslo (int) zabírá v paměti většinou 2 byty, výraz sizeof(int) nám tedy vrátí u většiny kompilátorů číslo 2.
===== Samostatné cvičení =====
* Vymyslete přiřazení co nejsložitějšího výrazu, jehož výsledkem bude hodnota false.
* Jakou hodnotu bude mít následující výraz:
* (((!(1 > 2 || 2 > 1)) * 2 + 4) / 2) == 7