\b;Wyrażenia
Wyrażenia używane są do wykonywania różnych obliczeń z różnymi zmiennymi w celu otrzymania żądanego wyniku. Od standardowych instrukcji odróżniają je opisane poniżej operatory.

Dokładniej rzecz ujmując, wyrażenie jest uporządkowaną serią działań przynoszącą pewien wynik. Działania składają się z operatorów, które są specjalnymi \l;funkcjami\u cbot\function; \c;T f(t1 x1, t2 x2, ..., tn xn)\n;, gdzie \c;xi\n; jest wartością typu \c;ti\n;, a \c;T\n; jest typem wyniku. Na przykład, \c;float +(float a, float b)\n; zwraca sumę wartości \c;a\n; i \c;b\n;. Uwaga: Operatory są częścią języka CBOT i nie mogą być zdefiniowane w programie. Oprócz tego, operatory nie mogą być używane jak zwykłe \l;funkcje\u cbot\function;, muszą być zapisane, używając specjalnej notacji zależnej od operatora, na przykład \c;a+b\n;.

W niemal każdym działaniu \l;stałe\u cbot;, \l;zmienne\u cbot\var;, \l;funkcje\u cbot\function; zwracające wartości typu nie\l;pustego\u cbot\void; i inne działania mogą być użyte jako wartości.

\b;Operacje binarne
Przyjmijmy, że \c;a\n;, \c;b\n; są wartościami zadeklarowanych i zainicjalizowanych zmiennych typów \c;t1\n; i \c;t2\n;, działania binarne można opisać w następujący sposób:
\s;\c;r = a op b\n;
Gdzie \c;r\n; jest wynikiem operacji, a \c;op\n; jest operatorem binarnym, który działa z wartościami typów \c;t1\n; i \c;t2\n;.

\t;Kolejność działań
Niech \c;a op1 b op2 c\n; będzie prawidłowym wyrażeniem, wtedy miejsce mają następujące reguły:
o Jeśli \c;op1 == op2\n; lub \c;op1\n; ma ten sam priorytet co \c;op2\n;, lub \c;op1\n; ma wyższy priorytet \c;op2\n;, najpierw oblicz \c;a op1 b\n; i przechowaj wynik działania w tymczasowej zmiennej \c;r\n;, a następnie oblicz \c;r op2 c\n;, co jest finałowym wynikiem wyrażenia.
o Jeśli \c;op1\n; ma mniejszy priorytet niż \c;op2\n;, najpierw oblicz \c;b op2 c\n; i przechowaj wynik działania w tymczasowej zmiennej \c;r\n;, a następnie oblicz \c;a op1 r\n;, co jest finałowym wynikiem wyrażenia.

Uwaga: działaniu można przypisać większy priorytet, umieszczając je w nawiasach. Na przykład przyjmując, że \c;op1\n; jest mniej ważne niż \c;op2\n;, w wyrażeniu \c;(a op1 b) op2 c\n; operacja \c;a op1 b\n; będzie wykonana jako pierwsza.

Wskazówka: zawsze używaj nawiasów jeśli nie jesteś pewnym kolejności działań, nie próbuj zapamiętać kolejności działań. W zasadzie to powinno być dość oczywiste.

Tu mamy do czynienia ze skomplikowanym przykładem używającym obliczeń arytmetycznych opisanych poniżej, co pokazuje nam, jak obliczane są wyrażenia:
\c;Przyjmijmy, że a, b, c, d, x, y, z, e są zainicjalizowanymi zmiennymi typu zmiennoprzecinkowego (float) lub całkowitego (int). W takim przypadku wyrażenia powinny zostać wykonane w następujący sposób:
  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 jest finałowym wynikiem wyrażenia.
\n;

\b;Operator przypisania
\c;=\n; jest operatorem przypisania. Używany jest do przechowywania wyniku wyrażenia w zmiennej.

Po lewej stronie tego operatora musi znaleźć się tak zwana l-wartość a po prawej stronie - p-wartość. L-wartości to po prostu \l;zmienne\u cbot\var;\n;, natomiast r-wartości są wyrażeniami lub zwykłymi wartościami. To sprawia, że operator przypisania jest dość unikatowy, ponieważ nie wszystko może być l-wartością (nie może to być wyrażenie, stała i podobne, jedynie pojedyncza zmienna). Oprócz tego typ l-wartości musi mieć ten sam typ co r-wartość (chyba że możliwa jest konwersja, na przykład przypisanie \c;\l;float\u cbot\float;\n; do \c;\l;int\u cbot\int;\n;).

Uwaga: to może nie być oczywiste na początku, ale zauważ, że \c;=\n; jest *operatorem*, nie instrukcją. To oznacza, że może zostać użyty przy tworzeniu innego wyrażenia! Wynik operatora \c;=\n; jest wartością, która została przypisana do l-wartości - inaczej mówiąc, operator ten zwraca wynik działania po jego prawej stronie. Przykład:
\c;
\s; float a;
\s; float b = 2.0 * (a = 4.0); // b == 8.0
\n;
Ten przykład jest dość mylący, ale ta właściwość jest całkiem użyteczna, gdyż pozwala na przeprowadzanie tego typu działań:
\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;Podstawowe operacje arytmetyczne
Operatory binarne poniżej działają z podstawowymi typami liczb (\c;\l;int\u cbot\int;\n;, \c;\l;float\u cbot\float;\n;).

\t;Lista
\c;+\n;  dodawanie
\c;-\n;  odejmowanie
\c;*\n;  mnożenie
\c;/\n;  dzielenie
\c;%\n;  reszta z dzielenia (działa dla \c;\l;int\u cbot\int;\n; oraz \c;\l;float\u cbot\float;\n;)

\t;Uwagi
o Operatory \c;*\n;, \c;/\n;, \c;%\n; mają pierwszeństwo nad \c;+\n; i \c;-\n;
o Wynikowym \l;typem\u cbot\type; zawsze jest \c;\l;float\u cbot\float;\n;. Jeśli \c;a\n; lub \c;b\n; są typu \c;\l;int\u cbot\int;\n;, zostaną automatycznie przekonwertowane do \c;\l;float\u cbot\float;\n;. Uwaga: to oznacza, że wyniki obliczeń pośrednich będą tak dokładne jak to możliwe, precyzja jest tracona tylko podczas konwersji finałowego (\c;\l;float\u cbot\float;\n;) wyniku do \c;\l;int\u cbot\int;\n;, na przykład przez operator \c;=\n;.

\t;Przykłady z życia wzięte
\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 (automatyczna konwersja do int)
\s; float  f = 5 / 3;       // f == 1.67
\s; float  f = 5 / 0;       // zwraca błąd (dzielenie przez zero)
\s; 
\s; int    i = 13 % 5;      // i == 3
\s; int    i = -8 % 3;      // i == -2
\s; float  f = -4.5 % 2.75; // f == -1.75
\s; 
\s; float  f = sin(90) * i; // f == -2.0
\s; 
\n;
\t;Złożone operatory przypisania
Oprócz operatora \c;=\n; do przypisywania zmiennych istnieją także różne złożone operatory przypisania.

Złożone operatory przypisania łączą operator przypisania \c;=\n; z innym operatorem binarnym, na przykład \c;+\n; lub \c;-\n;. Złożone operatory przypisania wykonują działanie określone przez dodatkowy operator, a następnie przypisują wynik do lewego operandu. Na przykład, taki złożony operator przypisania
\s;\c;l-wartość += wyrażenie\n;
jest równoważne
\s;\c;l-wartość = l-wartość + wyrażenie\n;

\t;Lista
\c;+=\n;  dodawanie
\c;-=\n;  odejmowanie
\c;*=\n;  mnożenie
\c;/=\n;  dzielenie
\c;%=\n;  reszta z dzielenia

\b;Łączenie łańcuchów znaków
Jeśli przynajmniej jedna z wartości używanych z operatorem \c;+\n; jest \l;łańcuchem znaków\u cbot\string;, wtedy wykonywana jest operacja łączenia. Wynik operatora w takim razie jest łańcuchem znaków tworzonym przez dołączenie do łańcucha znaków innej wartości. Jeśli inna wartość nie jest łańcuchem zostaje najpierw przekonwertowana.

\t;Przykłady
\c;
\s;	string s = "a" + "bc";  // zwraca "abc"
\s;	string s = 1 + "bc";    // zwraca "1bc"
\s;	string s = 2.5 + "bc";  // zwraca "2.5bc"
\s;	string s = "a" + true;  // zwraca "atrue"
\n;
Porada: właściwości operatora łączenia \c;+\n; są użyteczne podczas korzystania z funkcji \l;message();\u cbot\message;, ponieważ nie działa to ze zmiennymi innego typu niż string. Pusty łańcuch może być użyty razem z wartością, by stworzyć łańcuch, który może zostać przekazany do funkcji \l;message();\u cbot\message;:
\c;
\s; float pi = 3.14;
\s; // message(pi); // nie zadziała
\s; message(""+pi);
\n;
\b;Operatory porównania
Operatory porównania działają z wartościami typu \l;float\u cbot\float; i zawsze zwracają \l;bool\u cbot\bool;. Używane są głównie w \l;warunkach\u cbot\cond;.

\t;Lista
\c;a == b  \n;\c;a\n; równe \c;b\n;
\c;a != b  \n;\c;a\n; różne od \c;b\n;
\c;a <  b  \n;\c;a\n; mniejsze od \c;b\n;
\c;a <= b  \n;\c;a\n; mniejsze od lub równe \c;b\n;
\c;a >  b  \n;\c;a\n; większe od \c;b\n;
\c;a >= b  \n;\c;a\n; większe od lub równe \c;b\n;

\t;Przykłady
\c;12 == 12  \n;daje w wyniku true
\c;45 != 47  \n;daje w wyniku true 
\c;99 == 98  \n;daje w wyniku false
\c;12 <  -1  \n;daje w wyniku false
\c;12 >= 10  \n;daje w wyniku true 
\c;12 >= 12  \n;daje w wyniku true 

\t;Uwaga
Nie należy mylić operatora porównania \c;==\n; z operatorem przypisania wartości \l;zmiennej\u cbot\var; \c;=\n;.

\c;a == b\n; jest wyrażeniem porównującym \c;a\n; z \c;b\n;.
\c;a = b\n; jest wyrażeniem kopiującym wartość \c;b\n; do \c;a\n;.

\b;Operatory logiczne
Operatory logiczne działają z wartościami typu \l;bool\u cbot\bool; i zawsze zwracają \l;bool\u cbot\bool;. Głównie używa się ich w \l;warunkach\u cbot\cond;.

\t;Lista
\c;!a      \n;nie \c;a\n;
\c;a && b  \n;\c;a\n; i \c;b\n;
\c;a || b  \n;\c;a\n; lub \c;b\n;

\t;Przykłady
\c;!false        \n;zwraca true
\c;true && false \n;zwraca false 
\c;true || false \n;zwraca true

\b;Operatory trójskładnikowe
Operator trójskładnikowy to nic więcej niż skrót składniowy. Jest również znany jako "skrócony if". To może być na początku niejasne, ponieważ jego składnia jest trochę bardziej skomplikowana w porównaniu z innymi operatorami. Można to opisać w następujący sposób:
\c;(warunek) ? (wynik jeśli prawda) : (wynik jeśli fałsz)\n;
Nawiasy nie są wymagane.

Najpierw obliczany jest warunek i jeśli jest on prawdziwy, zwracany jest pierwszy wynik, w przeciwnym razie zwracany jest drugi wynik.

\t;Przykład
\s;\c;float c = ((3.0 > 2.0) ? 10.0 : -10.0); // c == 10.0\n;

\b;Operatory bitowe
Operatory bitowe są podobne do operatorów logicznych, gdyż działają na bitach (które mogą być tylko zerami lub jedynkami, warunki mogą mieć tylko wartości false lub true). Więc w teorii powinny działać z praktycznie każdym typem zmiennej, ponieważ każda wartość w komputerze musi być przechowywana w postaci sekwencji bitów.

\t;Lista
\c;a & b  \n;\c;a\n; AND \c;b\n;
\c;a | b  \n;\c;a\n; OR \c;b\n;
\c;a ^ b  \n;\c;a\n; XOR \c;b\n;
\c;a >> b  \n;przesuń bity z \c;a\n; w prawą stronę \c;b\n; razy
\c;a << b  \n;przesuń bity z \c;a\n; w lewą stronę \c;b\n; razy

\t;Przykłady
\c;2 & 1         \n;zwraca 0
\c;2 | 1         \n;zwraca 3
\c;2 ^ 2         \n;zwraca 0
\c;2 >> 1        \n;zwraca 1
\c;2 << 1        \n;zwraca 4

\b;Operatory zwiększania i zmniejszania przedrostka i przyrostka
Operatory \c;++\n; i \c;--\n; umożliwiają wygodny i zwarty zapis zwiększania (++) lub zmniejszania (--) zmiennych.

Na przykład: do zwiększenia wartości zmiennej \c;a\n; możesz napisać
\s;\c;a++;\n;
zamiast
\s;\c;a = a + 1;\n;

Wynik operacji \c;a++\n; jest równy wartości zmiennej \c;a\n; *przed* jej zwiększeniem. Jeśli użyjesz operatora przedrostkowego \c;++a\n; wynik operacji będzie wartością zmiennej \c;a\n; *po* jej zwiększeniu. To samo dotyczy się operatora zmniejszania \c;--\n;.

\t;Przykłady
\c;
\s; a = 2;
\s; b = a++;
\s; // teraz b jest równe 2, natomiast a jest równe 3

\s; a = 2;
\s; b = ++a;
\s; // teraz b jest równe 3, natomiast a również jest równe 3
\n;
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.
