\b;Výrazy
Výrazy se používají pro veškeré výpočty s různými proměnnými, které vracejí požadovaný výsledek. Oproti prostým příkazům se v nich používají operátory popsané níže.

Přesněji řečeno, výraz je uspořádaná série operací, která vrací výsledek. Operace určují operátory, což jsou speciální \l;funkce\u cbot\function; \c;T f(t1 x1, t2 x2, ..., tn xn)\n;, kde \c;xi\n; je hodnota typu \c;ti\n; a \c;T\n; je návratový typ. Například \c;float +(float x, float y)\n; vrací součet hodnot \c;x\n; a \c;y\n;. Poznámka: Operátory jsou součástí jazyka CBOT a v programu si nemůžete definovat vlastní. Operátory dále nemůžete volat jako běžné \l;funkce\u cbot\function;, ale musíte je zapisovat speciální syntaxí, která se liší podle operátoru, například \c;x+y\n;.

Téměř ve všech operacích můžete jako hodnoty použít \l;konstanty\u cbot;, \l;proměnné\u cbot\var;, \l;funkce\u cbot\function; vracející jiný typ než \l;void\u cbot\void; a také jiné operace.

\b;Binární operace
Nechť \c;x\n; a \c;y\n; jsou hodnoty deklarovaných a inicializovaných proměnných typů \c;t1\n; a \c;t2\n;, pak binární operace se dá popsat takto:
\s;\c;v = x op y\n;
Kde \c;v\n; je výsledek operace a \c;op\n; je binární operátor (tj. operátor přijímající 2 operandy), který pracuje s hodnotami typů \c;t1\n; a \c;t2\n;.

\t;Pořadí operací
Nechť \c;x op1 y op2 z\n; je platný výraz, pak platí následující pravidla:
o Pokud \c;op1 == op2\n; nebo \c;op1\n; má stejnou prioritu jako \c;op2\n; nebo \c;op1\n; má vyšší prioritu než \c;op2\n;, nejprve se vypočítá \c;x op1 y\n; a výsledek se uloží do dočasné proměnné \c;r\n;, pak se vypočítá \c;r op2 z\n;, což je konečný výsledek výrazu.
o Pokud \c;op1\n; má nižší prioritu než \c;op2\n;, nejprve se vypočítá \c;y op2 z\n; a výsledek se uloží do dočasné proměnné \c;r\n;, pak se vypočítá \c;x op1 r\n;, což je konečný výsledek výrazu.

Poznámka: pořadí operací lze vynutit pomocí závorek, takže například pokud \c;op1\n; má nižší prioritu než \c;op2\n;, ve výrazu \c;(x op1 y) op2 z\n; se jako první operace vypočítá \c;x op1 y\n;.

Tip: Pokud si nejste jistí pořadím operací, vždy používejte závorky, nesnažte se prioritu operátorů uhodnout. Většinou by pořadí operací mělo být celkem jasné.

Zde je složitý příklad s aritmetickými operacemi popsanými níže, který znázorňuje pořadí výpočtů:
\c;Nechť a, b, c, d, x, y, z, e jsou inicializované proměnné typu float nebo int. Pak se následující výraz vypočítá v níže rozepsaných krocích:
  a * b + c - d / x % (y * z) - e =
= r1 + c - d / x % (y * z) - e    = , r1 = a * b
= r2 - d / x % (y * z) - e        = , r2 = r1 + c
= r2 - r3 % (y * z) - e           = , r3 = d / x
= r2 - r3 % r4 - e                = , r4 = y * z
= r2 - r5 - e                     = , r5 = r3 % r4
= r6 - e                          = , r6 = r2 - r5
= r7                                , r7 = r6 - e
r7 je konečný výsledek výpočtu.
\n;

\b;Operátor přiřazení
\c;=\n; je operátor přiřazení. Používá se pro uložení výsledku výrazu do proměnné.

Na levé straně tohoto operátoru musí být takzvaná "l-hodnota" a na pravé straně - "r-hodnota". L-hodnoty jsou pouze \l;proměnné\u cbot\var;\n;, r-hodnoty jsou výrazy nebo prosté hodnoty. Operátor přiřazení je proto poněkud výjimečný, protože definice l-hodnoty je značně omezená (nesmí to být výraz, konstanta a podobně, pouze samotná proměnná). Dále se datový typ l-hodnoty musí shodovat s typem r-hodnoty (pokud není možná konverze, například při přiřazení hodnoty typu \c;\l;float\u cbot\float;\n; do proměnné typu \c;\l;int\u cbot\int;\n;).

Poznámka: Možná to na první pohled není zřejmé, ale všimněte si, že \c;=\n; je *operátor*, ne příkaz. To znamená, že ho můžete použít uvnitř jiného výrazu! Operátor \c;=\n; vrací hodnotu, která byla přiřazena do l-hodnoty - výsledek výrazu na pravé straně. Příklad:
\c;
\s; float a;
\s; float b = 2.0 * (a = 4.0); // b == 8.0
\n;
Tento příklad je sice poněkud matoucí, ale je to užitečná vlastnost, protože Vám umožňuje přiřazovat i takto:
\c;
\s; float a, b, c, d, e;
\s; a = b = c = d = e = 1.0; // a == b == c == d == e == 1.0
\n;
\b;Základní aritmetické operace
Binární operátory uvedené níže pracují se základními číselnými typy (\c;\l;int\u cbot\int;\n;, \c;\l;float\u cbot\float;\n;).

\t;Seznam
\c;+\n;  sčítání
\c;-\n;  odčítání
\c;*\n;  násobení
\c;/\n;  dělení
\c;%\n;  zbytek po dělení (pouze pro typ \c;\l;int\u cbot\int;\n;)

\t;Poznámky
o Operátory \c;*\n;, \c;/\n;, \c;%\n; mají vyšší prioritu než \c;+\n; a \c;-\n;.
o \l;Datový typ\u cbot\type; výsledku je vždy \c;\l;float\u cbot\float;\n;. Pokud je jeden z operandů typu \c;\l;int\u cbot\int;\n;, automaticky se zkonvertuje na \c;\l;float\u cbot\float;\n;. Poznámka: To znamená, že výsledky dílčích výpočtu mají vždy nejvyšší možnou přesnost, zaokrouhluje se až při konverzi konečného výsledku (typu \c;\l;float\u cbot\float;\n;) na typ \c;\l;int\u cbot\int;\n;, například operátorem přiřazení \c;=\n;.

\t;Reálné příklady
\c;
\s; int    i = 12 + 3;      // i == 15
\s; int    i = 2 - 5;       // i == -3
\s; 
\s; float  f = 3.01 * 10;   // f == 30.1
\s; 
\s; int    i = 5 / 3;       // i == 1 (automatická konverze na int)
\s; float  f = 5 / 3;       // f == 1.67
\s; float  f = 5 / 0;       // způsobí chybu (dělení nulou)
\s; 
\s; int    i = 13 % 5;      // i == 3
\s; int    i = -8 % 3;      // i == -2
\s; 
\s; float  f = sin(90) * i; // f == -2.0
\s; 
\n;
\t;Složené operátory přiřazení
Kromě operátoru \c;=\n; pro přiřazení do proměnné existuje i několik složených operátorů přiřazení.

Složené operátory přiřazení kombinují operátor přiřazení \c;=\n; s dalším binárním operátorem, například \c;+\n; nebo \c;-\n;. Složené operátory přiřazení provedou operaci určenou přidaným operátorem, a pak přiřadí výsledek do levého operandu. Například složený přiřazovací výraz
\s;\c;lhodnota += výraz\n;
dělá totéž jako
\s;\c;lhodnota = lhodnota + výraz\n;

\t;Seznam
\c;+=\n;  sčítání
\c;-=\n;  odčítání
\c;*=\n;  násobení
\c;/=\n;  dělení
\c;%=\n;  zbytek po dělení (pouze pro datový typ \c;\l;int\u cbot\int;\n;)

\b;Slučování řetězců
Pokud je alespoň jeden operand operátoru \c;+\n; typu \l;string\u cbot\string;, provede se sloučení řetězců. Výsledkem operace je textový řetězec vytvoření přilepením pravého řetězce na konec levého. Pokud jeden z operandů není typu string, před provedením operace se automaticky zkonvertuje na textový řetězec.

\t;Příklady
\c;
\s;	string s = "a" + "bc";  // vrátí "abc"
\s;	string s = 1 + "bc";    // vrátí "1bc"
\s;	string s = 2.5 + "bc";  // vrátí "2.5bc"
\s;	string s = "a" + true;  // vrátí "atrue"
\n;
Tip: Vlastnosti operátoru sloučení řetězců \c;+\n; jsou zvláště užitečné pro funkci \l;message();\u cbot\message;, protože ta nepřijímá žádný jiný typ než string. Můžete například sloučit prázdný řetězec s jinou hodnotou, abyste z ní vytvořili textový řetězec, který pak můžete předat funkci \l;message();\u cbot\message;:
\c;
\s; float pi = 3.14;
\s; // message(pi); // tohle nefunguje
\s; message(""+pi);
\n;
\b;Operátory porovnání
Operátory porovnání pracují s hodnotami typu \l;float\u cbot\float; a vždy vracejí hodnotu typu \l;bool\u cbot\bool;. Používají se především v \l;podmínkách\u cbot\cond;.

\t;Seznam
\c;x == y  \n;\c;x\n; se rovná \c;y\n;
\c;x != y  \n;\c;x\n; se nerovná \c;y\n;
\c;x <  y  \n;\c;x\n; je menší než \c;y\n;
\c;x <= y  \n;\c;x\n; je menší nebo rovno \c;y\n;
\c;x >  y  \n;\c;x\n; je větší než \c;y\n;
\c;x >= y  \n;\c;x\n; je větší nebo rovno \c;y\n;

\t;Příklady
\c;12 == 12  \n;vrátí true
\c;45 != 47  \n;vrátí true 
\c;99 == 98  \n;vrátí false
\c;12 <  -1  \n;vrátí false
\c;12 >= 10  \n;vrátí true 
\c;12 >= 12  \n;vrátí true 

\t;Poznámky
Dávejte pozor, abyste si nespletli porovnání na rovnost \c;==\n; s přířazením do \l;proměnné\u cbot\var; \c;=\n;.

\c;x == y\n; je výraz, který porovná \c;x\n; a \c;y\n;.
\c;x = y\n; je výraz, který zkopíruje hodnotu z \c;y\n; do \c;x\n;.

\b;Logické operátory
Logické operátory pracují s hodnotami typu \l;bool\u cbot\bool; a vždy vracejí hodnotu typu \l;bool\u cbot\bool;. Používají se především v \l;podmínkách\u cbot\cond;.

\t;Seznam
\c;!x      \n;negace \c;x\n;
\c;x && y  \n;musí platit \c;x\n; i \c;y\n; zároveň
\c;x || y  \n;musí platit alespoň jedno z \c;x\n; nebo \c;y\n;

\t;Příklady
\c;!false        \n;vrátí true
\c;true && false \n;vrátí false 
\c;true || false \n;vrátí true

\b;Ternární operátor
Ternární operátor není nic víc než syntaktický cukr. Také se mu říká "jednořádkový if." Zpočátku může být trochu matoucí, protože jeho syntaxe je trochu složitější než u ostatních operátorů. Ternární operátor se dá popsat takto:
\c;(podmínka) ? (výsledek pokud podmínka platí) : (výsledek pokud neplatí)\n;
Závorky nejsou nutné.

Nejprve se vyhodnotí podmínka. Pokud platí, vrátí se první výraz, jinak se vrátí druhý výraz.

\t;Příklad
\s;\c;float c = ((3.0 > 2.0) ? 10.0 : -10.0); // c == 10.0\n;

\b;Bitové operátory
Bitové operátory jsou podobné logickým operátorům, protože pracují s jednotlivými bity (které mohou mít pouze hodnotu 0 nebo 1, podobně jako podmínky mohou mít pouze hodnotu false nebo true). Takže teoreticky by měly fungovat se všemi datovými typy, protože v počítači jsou všechny hodnoty uloženy jako posloupnost bitů.

\t;Seznam
\c;x & y  \n;\c;x\n; AND \c;y\n;
\c;x | y  \n;\c;x\n; OR \c;y\n;
\c;x ^ y  \n;\c;x\n; XOR \c;y\n;
\c;x >> y  \n;posune bity \c;x\n; doprava o \c;y\n; míst
\c;x << y  \n;posune bity \c;x\n; doleva o \c;y\n; míst

\t;Příklady
\c;2 & 1         \n;vrátí 0
\c;2 | 1         \n;vrátí 3
\c;2 ^ 2         \n;vrátí 0
\c;2 >> 1        \n;vrátí 1
\c;2 << 1        \n;vrátí 4

\b;Unární operátory inkrementace a dekrementace
Operátory \c;++\n; a \c;--\n; Vám umožňují stručně a jednoduše hodnotu proměnné zvýšit (++) nebo snížit (--) o jedničku.

Například pro zvýšení hodnoty proměnné \c;x\n; o 1 můžete napsat
\s;\c;x++;\n;
místo
\s;\c;x = x + 1;\n;

Výraz \c;x++\n; vrací hodnotu proměnné \c;x\n; *před* zvýšením. Pokud použijete prefixový operátor \c;++x\n;, výraz vrátí hodnotu proměnné \c;x\n; *po* zvýšení. Totéž platí pro operátor dekrementace \c;--\n;.

\t;Příklady
\c;
\s; x = 2;
\s; y = x++;
\s; // y teď obsahuje 2, x obsahuje 3

\s; x = 2;
\s; y = ++x;
\s; // y teď obsahuje 3, x obsahuje 3
\n;
\t;Užitečné odkazy
\l;Programování\u cbot;, \l;datové typy\u cbot\type; a \l;kategorie\u cbot\category;.
