Expressões

• Expressões são constituidas por variáveis, constantes e operadores
• A linguagem C inclui operadores para:
  • aritmética (+, -, *, /)
  • comparações
  • operações lógicas
  • atribuição
  • pré- e pós-incremento e decremento

Operadores aritméticos

• Operadores binários (sobre dois valores)

• Operadores unários (sobre um valor)

Operadores aritméticos unários

• Necessitam apenas de um operando; exemplos:

    i = +1;
    j = -i;

• O operador + unário não tem qualquer efeito; é usado principalmente para sinalizar constantes positivas

Operadores aritméticos binários

• +, *, e / permitem misturar operandos inteiros e vírgula-flutuante
• Quando combinamos operandos int e float, o resultado é um float
  • ex: 2+0.5 dá 2.5; 3.5/2 dá 1.75

Divisão inteira

• Se os operandos são inteiros, o resultado de / é o quociente:
  • 3/4 dá 0
  • 10/3 dá 3
• i%j é o resto da divisão inteira de i por j:
  • 10%3 dá 1
  • 12%4 dá 0

Cuidados com / e %

• Ambos os operandos de % devem ser inteiros
• Se o lado direito de / ou % for 0, o resultado é indefinido (divisão por zero)
• Se o lado direito de % for negativo:
  • em C99: i%j tem o mesmo sinal que i
  • em C89/C90: depende da implementação

Precedência de operadores

• Como interpretar i+j*k?
  • "somar i com o resultado de multiplicar j por k"
  • "somar i com j e multiplicar o resultado por k"
• Podemos usar parêntesis para tornar o sentido não ambíguo:
  • i+(j*k) ou (i+j)*k
• Na ausência de parêntesis: a precedência entre operadores desambigua o significado

Precedência de operadores

1. Primeiro é avaliados + e - unários
2. Depois *, /, %
3. Por fim + e - binários

Exemplos

Associatividade de operadores

• A associatividade define como interpretar dois ou mais operadores com igual precedência
• Os operadores binários (+, -, *, /, %) associam à esquerda
• Os operadores unários associam à direita

Exemplos

Atribuição simples

• A atribuição \(var = expr\) calcula o valor de \(expr\) e copia-o para a variável \(var\)
• O lado direito pode ser uma constante, uma variável ou uma expressão complexa

    i = 5;            /* valor de i: 5  */
    j = i;            /* valor de j: 5  */
    k = 10 * i + j;   /* valor de k: 55 */

Atribuição simples (cont.)

Se a variável e expressão não forem do mesmo tipo dá-se uma conversão implícita de tipos.

   int i;
   float f;
    
   i = 72.99;   // valor de i: 72 
   f = 136;     // valor de f: 136.0 

Atribuições são expressões

• Na linguagem C uma atribuição é também uma expressão
• O resultado de \(var = expr\) é o valor que foi atribuido

Exemplo:

int i, j, k;
i = 1;
k = 1 + (j = i);
   // j: 1, k: 2

Cuidado: usar atribuições no meio de expressões pode dificultar a compreensão de programas

Atribuições em sequência

Podemos atribuir um mesmo valor a várias variáveis:

i = j = k = 0;

Como a atribuição associa à direita, isto é equivalente a:

i = (j = (k = 0));

Valores esquerdos (Lvalues)

• O lado esquerdo de uma atribuição corresponde a um local na memória ("lvalue")
• Uma variável é um lvalue, mas as constantes ou expressões compostas não são
• O compilador assina erro numa atribuição com lado esquerdo inválido: "invalid lvalue in assigment"

i = 12;    // OK: i é um lvalue
12 = i;    // erro: 12 não é um lvalue
1+j = 12;  // erro: 1+j não é um lvalue

Atribuição composta

É frequente atribuir a uma variável um novo valor que depende do seu valor atual.

Exemplo:

i = i + 2;

Nestes casos podemos usar uma atribuição composta:

i += 2;

Operadores de atribuição composta

\(v\) += \(e\)

adicionar \(e\) de \(v\), guardando o resultado em \(v\)

\(v\) -= \(e\)

subtrair \(e\) a \(v\), guardando o resultado em \(v\)

\(v\) *= \(e\)

multiplicar \(e\) por \(v\), guardando o resultado em \(v\)

\(v\) /= \(e\)

dividir \(v\) por \(e\), guardando o resultado em \(v\)

\(v\) %= \(e\)

calcular o resto de divisão de \(v\) por \(e\), guardando o resultado em \(v\)

Incremento e decremento

É frequente somar ou subtrair uma variável inteira de uma unidade.

i = i + 1;
j = j - 1;

Também aqui podemos usar uma atribuição composta:

i += 1;
j -= 1;

Em alternativa, podemos usar operadores de incremento ou decremento.

Incremento e decremento (cont.)

• A linguagem C tem operadores especiais para incremento e decremento
• Podem ser usados de forma prefixa (++i ou --i) ou pósfixa (i++ ou i--)

++i;        // equivalente a i = i + 1
--j;        // equivalente a j = j - 1

Pré- e pós-incremento

++i modifica a variável i (incrementa de uma unidade) e dá o valor resultante.

i = 1;
printf("%d\n", ++i);  // imprime 2
printf("%d\n", i);    // imprime 2

i++ dá o valor atual de i e depois modifica a variável i (incrementa de 1 unidade).

i = 1;
printf("%d\n", i++);  // imprime 1
printf("%d\n", i);    // imprime 2

Pré- e pós-incremento

• ++i incrementa imediatamente, enquanto i++ incrementa mais tarde
• O standard de C não especifica exatamente quando acontece o pós-incremento, mas é seguro assumir que i será incrementada antes da próxima instrução

Pré- e pós-decremento

O operador de decremento comporta-se de forma análoga ao de incremento:

i = 1;
printf("%d\n", --i);  // imprime 0
printf("%d\n", i);    // imprime 0
i = 1;
printf("%d\n", i--);  // imprime 1
printf("%d\n", i);    // imprime 0

Incremento e decremento

Pode ser difícil seguir o efeito de múltiplos ++ ou -- em várias variáveis numa mesma expressão:

i = 1;
j = 2;
k = ++i + j++;
 // i: 2, j: 3, k: 4

i = 1;
j = 2;
k = i++ + j++;
 // i: 2, j: 3, k: 3

Recomendação: evite expressões com mútiplos incrementos.

Ordem de avaliação

a = 5;
c = (b = a + 2) - (a = 1);

Qual é o valor final de c?

Ordem de avaliação

• O padrão da linguagem C não garante uma ordem para avaliação de subexpressões
  • e.g.: ao calcular (a + b) * (c - d) não sabemos se será calculado primeiro (a + b) ou (c - d)
• Para a maior parte das expressões, a ordem de avaliação não afeta o resultado
• Contudo: pode afetar o resultado se as sub-expressões modificarem variáveis:
  • e.g.: (b = a + 2) - (a = 1)

Outro exemplo

i = 2;
j = i * i++;

O resultado final de j depende da ordem de avaliação da multiplicação (4 ou 6).

Comportamento indefinido

• Expressões como c=(b=a+2)-(a=1); ou j=i*i++; têm comportamento indefinido:
  • podem dar resultado diferentes com compiladores diferentes
  • podem não executar, terminar abruptamente ou dar resultados errados
• Devemos sempre evitar expressões com comportamento indefinido
• O compilador ajuda a detetar alguns comportamento indefinidos com a opção de compilação -Wall:

       gcc -Wall -o programa programa.c

Comportamento indefinido

Re-escrever o primeiro exemplo para evitar comportamento indefinido:

a = 5;
b = a + 2;
a = 1;
c = b - a;

Desta forma o resultado final de c é sempre 6.