\b;Expressões
Expressões são usadas para vários cálculos com muitas variáveis diferentes, as quais retornam o resultado desejado. O que dinstingue elas de instruções padrões são os operadores que estão descritos abaixo:

Especificamente falando, uma expressão é uma série de operações ordenadas que produzem um resultado. Operações consistem de operadores, que são \l;funções\u cbot\function; especiais \c;T f(t1 x1, t2 x2, ..., tn xn)\n;, onde \c;xi\n; é um valor do tipo \c;ti\n;, e \c;T\n; é o tipo do resultado. Por exemplo, \c;float +(float a, float b)\n; retorna a soma dos valores \c;a\n; e \c;b\n;. Nota: operadores são parte da linguagem CBOT e eles não podem ser definidos no programa. Além disso, os operadores não pode ser usados como \l;funções\u cbot\function; normais, eles precisam ser escritos usando uma notação especial dependendo do operador, por exemplo, \c;a+b\n;.

Em quase todas as operações, \l;constantes\u cbot;, \l;variáveis\u cbot\var; e \l;funções\u cbot\function; retornam um tipo não \l;nulo\u cbot\void; e além disso outras operações podem ser utilizadas como valores.

\b;Operações binárias
Assumindo que \c;a\n; e \c;b\n; podem ser valores de variáveis declaradas e inicializadas dos tipos \c;t1\n; e \c;t2\n;, as operações binárias podem ser descritas da seguinte forma:
\s;\c;r = a op b\n;
Onde \c;r\n; é o resultado da operação e \c;op\n; é um operador binário que funciona com os valores do tipos \c;t1\n; e \c;t2\n;.

\t;Ordem das operações
Deixe \c;a op1 b op2 c\n; ser uma expressão legal, então as seguintes regras se aplicam:
o Se \c;op1 == op2\n; ou \c;op1\n; é tão forte quanto \c;op2\n; ou \c;op1\n; é mais forte que \c;op2\n;, primeiro calcule \c;a op1 b\n; e armazene o resultado em uma variável temporária \c;r\n;, depois calcule \c;r op2 c\n;, o qual será o resultado final da expressão.
o Se \c;op1\n; é mais fraco que \c;op2\n;, primeiro calcule \c;b op2 c\n; e armazene o resultado em uma variável temporária \c;r\n;, então calcule \c;a op1 r\n;, o qual será o resultado final da expressão.

Nota: uma operação pode se tornar mais forte se rodeada por parênteses, então por exemplo, assumindo que \c;op1\n; é mais fraco que \c;op2\n;, em uma expressão \c;(a op1 b) op2 c\n;, a operação \c;a op1 b\n; será executada primeiro.

Dica: sempre use parênteses se você não tem certeza sobre a ordem das operações, não tente se lembrar o quão forte é cada um dos operadores. Normalmente deve ser bastante óbvio.

Aqui está um exemplo complicado, o qual usa operações aritméticas descritas abaixo, mostrando como as expressões são calculadas:
\c;Assuma que a, b, c, d, x, y, z, e são variáveis inicializadas do tipo float ou int. Então a seguinte expressão deveria ser calculada da seguinte forma:
  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 é o resultado final desta expressão.
\n;

\b;Operador de atribuição
\c;=\n; é o operador de atribuição. Ele é usado para armazenar o resultado de uma expressão em uma variável.

Do lado esquerdo do operador deve haver o chamado valor-L e do lado direito o valor-R. Valores-L são apenas \l;variáveis\u cbot\var;\n;, valores-R são expressões ou apenas valores usuais. Isto torna o operador de atribuição um pouco especial, porque o que pode ser valor-L é bem restritivo (não pode ser uma expressão, constante e assim por diante, somente uma única variável). Também, o tipo do valor-L deve bater com o tipo do valor-R (a menos que uma conversão seja possível, por exemplo, atribuir um \c;\l;float\u cbot\float;\n; para um \c;\l;int\u cbot\int;\n;).

Nota: pode não ser óbvio de primeira, porém note que \c;=\n; é um *operador*, não uma instrução. Isto significa que ele pode ser usado no meio de outra expressão! O resultado de \c;=\n; é o valor que está atribuido do lado do valor-L, o resultado da expressão na direita. Exemplo:
\c;
\s; float a;
\s; float b = 2.0 * (a = 4.0); // b == 8.0
\n;
Este exemplo é realmente confuso, porém este uso é atualmente útil, porque ele está fazendo algo como isso:
\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;Operações aritméticas básicas
As operações binárias abaixo funcionam com os tipos numéricos fundamentais (\c;\l;int\u cbot\int;\n;, \c;\l;float\u cbot\float;\n;).

\t;Lista
\c;+\n;  adição
\c;-\n;  subtração
\c;*\n;  multiplicação
\c;/\n;  divisão
\c;%\n;  resto da divisão (somente para o tipo \c;\l;int\u cbot\int;\n;)

\t;Notas
o Os operadores \c;*\n;, \c;/\n;, \c;%\n; são mais fortes que \c;+\n; e \c;-\n;.
o O \l;tipo\u cbot\type; do resultado é sempre \c;\l;float\u cbot\float;\n;. Se \c;a\n; ou \c;b\n; são do tipo \c;\l;int\u cbot\int;\n;, eles são automaticamente convertidos para \c;\l;float\u cbot\float;\n;. Nota: isto significa que os resultados de cálculos intermediários tendem a ser tão precisos quanto possivel, a precisão é perdida somente durante a conversão final (\c;\l;float\u cbot\float;\n;)  do resultado para \c;\l;int\u cbot\int;\n;, por exemplo, pela atribuição do operador \c;=\n;.

\t;Exemplos da vida real
\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 (conversão automática para int)
\s; float  f = 5 / 3;       // f == 1.67
\s; float  f = 5 / 0;       // retorna erro (divisão por zero)
\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;Operadores de atribuição compostos
Além do operador \c;=\n; para atribuição a variáveis, existem muitos outros operadores de atribuição compostos.

Os operadores de atribuição compostos combinam o operador de atribuição  \c;=\n; com outro operador binário como \c;+\n; ou \c;-\n;. Operadores de atribuição compostos realizam a operação especificada pelo operador adicional e depois atribuem o resultado a esquerda do operador. Por exemplo, uma expressão de atribuição composta como
\s;\c;valor-L += expressao\n;
é equivalente a
\s;\c;valor-L = valor-L + expressao\n;

\t;Lista
\c;+=\n;  adição
\c;-=\n;  subtração
\c;*=\n;  multiplicação
\c;/=\n;  divisão
\c;%=\n;  resto da divisão (somente para o tipo \c;\l;int\u cbot\int;\n;)

\b;Concatenação de strings
Se pelo menos um dos valores usados com o operador \c;+\n; é uma \l;string\u cbot\string;, então uma operação de concatenação é realizada. O resultado do operador é então uma string, a qual é criada pela junção fim-a-fim da string com o outro valor. Se o outro valor não é uma string, então ela é convertida para string antecipadamente.

\t;Exemplos
\c;
\s;	string s = "a" + "bc";  // retorna "abc"
\s;	string s = 1 + "bc";    // retorna "1bc"
\s;	string s = 2.5 + "bc";  // retorna "2.5bc"
\s;	string s = "a" + true;  // retorna "atrue"
\n;
Dica: as propriedades do operador de concatenação \c;+\n; são úteis com a função \l;message();\u cbot\message;, porque ela não funciona com outros tipos que não sejam string. Uma string vazia pode ser utilizada junto com um valor a fim de criar uma string, a qual depois pode ser passada para a função \l;message();\u cbot\message;:
\c;
\s; float pi = 3.14;
\s; // message(pi); // não funciona
\s; message(""+pi);
\n;
\b;Operadores de comparação
Operadores de comparação funcionam com valores do tipo \l;float\u cbot\bool; e eles sempre retornam um \l;bool\u cbot\bool;. Eles são frequentemente usados em \l;condições\u cbot\cond;.

\t;Lista
\c;a == b  \n;\c;a\n; é igual a \c;b\n;
\c;a != b  \n;\c;a\n; é diferente de \c;b\n;
\c;a <  b  \n;\c;a\n; é menor que \c;b\n;
\c;a <= b  \n;\c;a\n; é menor ou igual a \c;b\n;
\c;a >  b  \n;\c;a\n; é maior que \c;b\n;
\c;a >= b  \n;\c;a\n; é maior ou igual a \c;b\n;

\t;Exemplos
\c;12 == 12  \n;retorna true
\c;45 != 47  \n;retorna true 
\c;99 == 98  \n;retorna false
\c;12 <  -1  \n;retorna false
\c;12 >= 10  \n;retorna true 
\c;12 >= 12  \n;retorna true 

\t;Observação
Tenha cuidado para não confundir o operador de comparação \c;==\n; com o operadoratribuição de valor a \l;variáveis\u cbot\var; \c;=\n;.

\c;a == b\n; é uma expressão que compara \c;a\n; com \c;b\n;.
\c;a = b\n; é uma expressão que copia o valor de \c;b\n; em \c;a\n;.

\b;Operadores lógicos
Operadores lógicos funcionam com valores do tipo \l;bool\u cbot\bool; e eles sempre retorna um  \l;bool\u cbot\bool;. Eles são frequentemente utilizados em  \l;condições\u cbot\cond;.

\t;Lista
\c;!a      \n;não \c;a\n;
\c;a && b  \n;\c;a\n; e \c;b\n;
\c;a || b  \n;\c;a\n; ou \c;b\n;

\t;Exemplos
\c;!false        \n;retorna true
\c;true && false \n;retorna false 
\c;true || false \n;retorna true

\b;Operador ternário
O operador ternário nada mais é do que sintaxe reduzida. Também é conhecido como "if em linha". Pode ser confuso de início, porque sua sintaxe é um pouco mais complicada que os outros operadores. Ele pode ser descrito desta forma: 
\c;(condicao) ? (resultado quando true) : (resultado quando false)\n;
Parênteses não são necessários.

Primeiramente, a condição é avaliada e então o primeiro resultado é retornado se a condição for verdadeira, caso contrário o segundo resultado é retornado.

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

\b;Operadores bit a bit
Operadores bit a bit são similares aos operadors lógicos, porque eles estão operando em bits (que podem ser somente 0 ou 1, condições só podem ter um valor de falso ou verdadeiro). Então em teoria, eles devem conseguir trabalhar com praticamente qualquer tipo de variável, porque cada valor no computador deve ser armazenado como uma sequência de bits.

\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;desloca bits de \c;a\n; para a direita \c;b\n; vezes
\c;a << b  \n;desloca bits de a \c;a\n; para a esquerda \c;b\n; vezes

\t;Exemplos
\c;2 & 1         \n;retorna 0
\c;2 | 1         \n;retorna 3
\c;2 ^ 2         \n;retorna 0
\c;2 >> 1        \n;retorna 1
\c;2 << 1        \n;retorna 4

\b;Operadores de incremento e decremento de prefixo e sufixo
Os operadores \c;++\n; e \c;--\n; permitem a você incrementar (++)ou decrementar (--) uma variável de uma maneira bem compacta e eficiente.

Por exemplo, para incrementar a variável \c;a\n; você pode escrever
\s;\c;a++;\n;
em vez de
\s;\c;a = a + 1;\n;

O resultado da operação \c;a++\n; é o valor da variável \c;a\n; *antes* do incremento. Se você usar o operador prefixo \c;++a\n;, o resultado da operação será o valor da variável \c;a\n; *após* o incremento. O mesmo se aplica ao operador de decremento \c;--\n;.

\t;Exemplos
\c;
\s; a = 2;
\s; b = a++;
\s; // agora b contém 2 e a contém 3

\s; a = 2;
\s; b = ++a;
\s; // agora b contém 3 e a contém 3
\n;
\t;Veja também
\l;Programação\u cbot;, \l;tipos\u cbot\type; e \l;categorias\u cbot\category;.
