Close

Operátory v C/C++ – 1. díl

Programovací jazyky - Wordcloud - Zdroj Wikipedia Commons

Abychom mohli v programovacím jazyku vůbec něco naprogramovat, obsahuje jazyk dle typu různé skupiny použitelných konstrukcí. Jsou to podmíněné bloky (if…else), cykly (while, for, …) a další. Samostatnou skupinou jsou operátory, které slouží jednoduše k tomu, abychom z nějaké hodnoty udělali hodnotu jinou. S operátory jste se už určitě setkali. Může to být třeba znaménko + tak, jak jej známe z matematiky.

V tomto a následujících článcích si představíme výběr nejpodstatnějších operátorů z C/C++. Ucelený přehled naleznete například na Wikipedii.

Dělení operátorů

Operátory lze dělit podle několika kritérií. První z dělení je podle tzv. arity, druhé dělení podle toho, jak operátory přistupují k hodnotám, které jim „poskytneme“.

Dělení dle arity

Arita nám říká, kolik hodnot musíme operátoru „předložit“, aby byl schopný vypočítat novou hodnotu. Těmto hodnotám budeme dále říkat operandy. V C/C++ nalezneme operátory s aritou 1, 2 a 3. Říkáme jim také unární, binární a ternární operátory. Dále si představíme pouze příklady operátorů v jednotlivých skupinách dle arity a podrobněji si je popíšeme ve druhém způsobu dělení.

Unární operátory

Této skupině operátorů stačí k získání hodnoty pouze jeden operand. Patří mezi ně například unární -x (minus), nebo *x (získání hodnoty ukazatele – viz článek o ukazatelích).

Binární operátory

Operátory z této skupiny jsou jistě všem důvěrně známé, protože jsme je používali už na základní škole. Jsou to například x+y, nebo x<y.

Ternární operátor

Ternární operátor nalezneme v C/C++ pouze jeden. Je jím operátor c ? x : y. Jeho zápis může vypadat trochu podivně. Nejdříve se program podívá na operátor c a pokud je jeho hodnota vyhodnocena jako pravda, má výraz hodnotu x, jinak má hodnotu y. Tento operátor si ukážeme na příkladu.

int maximum = (x > y) ? x : y;
// pro x = 10, y = 20 -> maximum = 20
// pro x = 30, y = 20 -> maximum = 30

Dělení dle přístupu k operandům

Druhou možností dělení je podle toho, jakým způsobem operátory přistupují k operandům. Jsou to operátory:

  • aritmetické
  • relační
  • logické
  • bitové
  • operátory přiřazení
  • operátory přetypování
  • pomocné operátory

Aritmetické operátory

Tyto operátory jsou nejintuitivnější a většinu znáte ze školy. K operandům přistupují jako k číselným hodnotám (tj. 4 + 7 je 11 apod.). Musíme si u nich dát pozor na to, aby se výsledek vešel do proměnné, do které ho ukládáme.

Operátor plus

Operátor plus se vyskytuje v binární i unární podobě. V unární podobě je zde spíše jako doplnění unárního operátoru minus. Lze jej ale využít v pár speciálních případech.

// binární plus
a + b  
1 + 2

// unární plus
+a
+4

Operátor minus

Take se vyskytuje v unární i binární podobě. V unární podobě obrací znaménko čísla.

// binární minus
a - b  
1 - 2

// unární minus
-a
-4

// použití unárního + a - (+ není nutné uvádět, ale může sjednotit zápis)
int x[] = {+1, -1, +2, -2, ...}

Operátory násobení, dělení a modulo

Mají pouze binární variantu.

a * b   // násobení
a / b   // dělení
a % b   // modulo (zbytek po dělení)

Za komentář stojí operátor modulo, který vrací zbytek po dělení. Tedy:

0 % 4 = 0 // zbytek po dělení 0/4 je 0
1 % 4 = 1 // zbytek po dělení 1/4 je 1
2 % 4 = 2 // zbytek po dělení 2/4 je 2
3 % 4 = 3
4 % 4 = 0
5 % 4 = 1
...

Pro chování modula se zápornými operandy viz tato diskuse.

Operátory inkrementace a dekrementace

I s těmito operátory jste se pravděpodobně setkali – například v cyklu for. Jsou to unární operátory, přičemž operátor ++ inkrementuje hodnotu o 1 (tj. zvyšuje o 1), operátor – – ji dekrementuje (snižuje). Tyto dva operátory navíc mají tzv. prefixovou a postfixovou variantu, které se od sebe mírně liší chováním.

a++ // postfixové ++
++a // prefixové  ++
a-- // postfixové --
--a // prefixové  --

Serial.begin(9600);

int a, b;

// následující dva příklady se funkčně neliší
a = 10;
a++;                // zvýší hodnotu a o 1
Serial.println(a);  // vypíše 11

a = 10;
++a;                // zvýší hodnotu a o 1
Serial.println(a);  // vypíše 11

// následující dva už ano
a = 10;
b = a++;            // načte se hodnota a, ta se uloží do b a poté se hodnota a zvýší o 1 => a = 11, b = 10
Serial.print(a);    // vypíše 11
Serial.print(' ');
Serial.println(b);  // vypíše 10
                    
a = 10;
b = ++a;            // hodnota a je zvýšena o 1, tato nová hodnota je uložena do b
Serial.print(a);    // vypíše 11
Serial.print(' ');
Serial.println(b);  // vypíše 11

Poznámka: Pro binární operátory se v C/C++ používá tzv. infixová notace, např. (a + b). Matematika ale připouští pro binární operátory i prefixovou, či postfixovou notaci (obecně i pro n-ární operátory). Pro plus by prefixová notace vypadala (+ a b), postfixová (a b +). Pokud jste někdy používali jazyk LISP, tak tento jazyk využívá právě prefixové notace.

O dalších skupinách operátorů si povíme zase příště.

Zbyšek Voda

Už nějaký čas se zajímám o věci kolem Internetu věcí a otevřeného hardware a software. Tak jsem se také v roce 2010 dostal k Arduinu, pro které dodnes programuji a taky píšu články o práci s ním. Baví mě vymýšlet, jak staré věci používat novým způsobem.
Zbyšek Voda

Latest posts by Zbyšek Voda (see all)

Napsat komentář