Programovanie‎ > ‎Operátory‎ > ‎

Zložené operátory

Použitie zložených priraďovacích operátorov zjednodušuje a sprehľadňuje zdrojový kód, no použitie nie je bezpodmienečne nutné. Zlo­že­né pri­ra­ďo­va­cie ope­rá­to­ry ma­jú bez vý­nim­ky tvar op=, kde op je vždy niek­to­rý z bi­nár­nych ope­rá­to­rov. Sé­man­ti­ka zlo­že­ných ope­rá­to­rov pri­ra­de­nia je nas­le­du­jú­ca: vý­raz E1 op= E2 je ek­vi­va­lent­ný výrazu E1 = E1 op E2. Vý­sle­dok E1 op E2 sa pred pri­ra­de­ním späť do E1 kon­ver­tu­je na typ E1. Zlo­že­né ope­rá­to­ry sú takisto bi­nár­ne a aso­ciu­jú sa rov­na­ko ako jednoduchý ope­rá­tor =, ich ope­ran­dy však mu­sia byť pri­mi­tív­nych ty­pov. Je­di­nou vý­nim­kou je ope­rá­tor +=, kto­ré­ho ľa­vý ope­rand mô­že byť ty­pu String, pra­vý ope­rand v ta­kom prí­pa­de môže mať ľubovoľný typ.


++ (inkrementácia)  -- (dekrementácia)

Tieto dva ope­rá­to­ry slú­žia na in­kre­men­tá­ciu (++) a dek­re­men­tá­ciu (––) pre­men­ných. In­kre­men­to­vať pre­men­nú zna­me­ná zvý­šiť jej hod­no­tu o 1, dek­re­men­tá­cia pred­sta­vu­je, zní­že­nie hod­no­ty o 1. Oba ope­rá­to­ry sú unár­ne a exis­tu­jú v dvoch va­rian­toch: pre­fixovom (ope­rá­tor je pred ope­ran­dom) a po­stfixovom (ope­rá­tor je za ope­ran­dom). Ich je­di­ným ope­ran­dom mu­sí po­vin­ne byť pre­men­ná čí­sel­né­ho ty­pu.

x++   // inkrementácia x o 1 a vráti pôvodnú hodnotu x (prefix)
++x   // inkrementácia x o 1 a vráti novú hodnotu x (postfix)

x--   // dekrementácia x o 1 a vráti pôvodnú hodnotu x (prefix)
--x   // dekrementácia x o 1 a vráti novú hodnotu x  (postfix)

Vý­sled­ný efekt ap­li­ká­cie pre­fixové­ho a po­stfixové­ho va­rian­tu ope­rá­to­ra ++, resp. –– je rov­na­ký: in­kre­men­tá­cia, resp. dek­re­men­tá­cia. Oba va­rian­ty však sa lí­šia výslednou hod­no­tou vý­ra­zu ob­sa­hu­jú­ce­ho prís­luš­ný ope­rá­tor. Pri po­uži­tí po­stfixové­ho va­rian­tu je vý­sled­kom vý­ra­zu hod­no­ta pre­men­nej pred in­kre­men­tá­ciou/dek­re­men­tá­ciou, pri po­uži­tí pre­fixové­ho va­rian­tu je vý­sled­kom vý­ra­zu hod­no­ta pre­men­nej po in­kre­men­tá­cii/dek­re­men­tá­cii. Ukáž­me si to na prík­la­de:

x = 2;
y = ++x;   // x teraz obsahuje 3, y obsahuje 3 (novú hodnotu x)
z = x++;   // x teraz obsahuje 3, z obsahuje 2 (pôvodnú hodnotu x pred inkrementáciou)

+=  -=  *=  /=  %=  &=  |=

S väčšinou operátorov sa dá použiť aj ich skrátená forma. Napríklad nemusíme písať výraz A = A+3, ale napíšeme len A +=3. Táto možnosť je mohutne využívaná, i keď nemá prakticky žiadny význam (až na skrátenie kódu a jedno miesto na jednu takúto operáciu :-).

x += y;   // výraz: x = x + y;
x -= y;   // výraz: x = x - y; 
x *= y;   // výraz: x = x * y; 
x /= y;   // výraz: x = x / y; 
x %= y;   // výraz: x = x % y;
x &= y;   // výraz: x = x & y;
x |= y;   // výraz: x = x | y; 

Skrátená forma operátorov sa dá použiť s aritmetickými a bitovými operátormi (s vínimkou negácie), čiže len s binárnymi operátormi.

Operátor &= je často používaný s premennou alebo s konštantou na nastavenie jednotlivých bitov v premennej na nízky stav (logická 0). Tomu sa často hovorí v programovacích sprievodcov ako "resetovanie" bitov.

x  x  x  x  x  x  x  x     1  0  1  0  1  0  1  0    hodnota
1  1  1  1  1  1  0  0     1  1  1  1  1  1  0  0    maska: 1 ponechá hodnotu; 0 nastaví na nulu
----------------------     ----------------------
x  x  x  x  x  x  0  0     1  0  1  0  1  0  0  0    výsledná hodnota

Operátor |= je často používaný s premennou alebo s konštantou na nastavenie jednotlivých bitov v premennej na vysoký stav (logická 1).

x  x  x  x  x  x  x  x     1  0  1  0  1  0  1  0    hodnota
0  0  0  0  0  0  1  1     0  0  0  0  0  0  1  1    maska: 0 ponechá hodnotu; 1 nastaví na jedna
----------------------     ----------------------
x  x  x  x  x  x  1  1     1  0  1  0  1  0  1  1    výsledná hodnota