Operadores em C

Um operador é um símbolo que indica a realização de uma operação sobre uma ou mais variáveis ou valores. Há uma grande diversidade de operadores em C, sendo os principais apresentados nesta seção.

Operadores aritméticos

Os principais operadores aritméticos são descritos abaixo. O "módulo" é o resto da divisão inteira. Conside que A=10 e B=20.

Os operadores de incremento e decremento têm dois sabores, pré- e pós-fixados. No caso pré-fixado, (++a), o incremento ocorre antes que o valor seja usado; no caso pós-fixado, (a++), o incremento ocorre depois que o valor for utilizado. Suponha que n=5, então

x = n++;    // atribui e depois incrementa: x=5, n=6
y = ++n;    // incrementa e depois atribui: y=7, n=7

faz com que 5 seja atribuído a x, e faz com que 7 seja atribuído a y. Após a execução dos dois comandos, n=7.

Operadores relacionais

Conside que A=10 e B=20.

Operadores lógicos

Considere que A=TRUE e B=FALSE.

Operadores de atribuição

Considere que A=10 e B=20.

As atribuições-com-operação ('+=', '*=') são, frequentemente, mais naturais do que a atribuição simples; pensamos "incremente x de 5" (x += 5;) quando queremos fazer "x=x+5", mas não pensamos "adicione cinco a x e atribua o resultado para x".

Operadores bit-a-bit

Considere duas variáveis inteiras de 8 bits sem sinal:

• A = 0001 0001 (17)
• B = 0110 0011 (99)

Operadores diversos

Ordem de precedência

A ordem de precedência dos operadores vistos acima define a sequência em que os operadores serão aplicados. A ordem de precedência pode ter forte influência sobre o resultado da avaliação de expressões complexas.

A tabela a seguir indica a ordem de precedência dos principais operadores em C, da maior para a menor. Todos os operadores associam da esquerda para a direita, exceto os indicados na descrição.

A formatação livre de C nos permite abusar da legibilidade de muitas formas. Por exemplo, o que significa o comando (válido) abaixo?

x = a+++b;

poderia ser

x = a + ++b;

ou

x = a++ + b;

As regras de precedência resolvem este caso:

x = a + (++b);  // ++ tem maior precedência do que +

Exercícios

1. (Kelley&Pohl) Considerando a=1, b=2, c=3, d=4, e=5 compute as expressões abaixo.

a * b / c
a * b % c + 1
++ a * b - c --
7 - - b * ++ d
a / b / c
7 + c * -- d / e
2 * a % - b + c + 1
39 / - ++ e - + 29 % c
7 - + ++ a % (3+b)

2. (Kelley&Pohl) Considerando i=1, j=2, k=3, m=4, compute as expressões abaixo.

i += j + k
j *= k = m + 5
i += j += k += 1 + 2

3. (K&R) A função bitcount conta o número de bits em 1 no seu argumento. Corte o programa abaixo, compile-o e altere os valores atribuídos a a,b,c e verifique os resultados.

#include <stdio.h>              // inclusão de definições

int bitcount(unsigned int);     // declaração da função


int main (void)                 // função principal
{
   int a, b, c, n;              // declaração das variáveis

   a = 10;                      // valores para os lados dos triângulos
   b = 100;
   c = 1000;

   n = bitcount(a);
   printf ("a: %6d 0x%04x \t bits: %d\n", a, a, n);  // imprime resultado na tela

   n = bitcount(b);
   printf ("b: %6d 0x%04x \t bits: %d\n", b, b, n);  // imprime resultado na tela

   n = bitcount(c);
   printf ("c: %6d 0x%04x \t bits: %d\n", c, c, n);  // imprime resultado na tela

  return (0);                    // retorno (fim) da função
}

int bitcount(unsigned int x)
{
    int b;

    for (b = 0; x != 0; x >>= 1) // atribuição com deslocamento
       if (x & 1)
          b++;
    return b;
}

A string nos printf() significa:

"a: ", depois um decimal (%d) alinhado à direita em seis 'casas' (%6d), depois um hexadecimal (%x) alinhado à direita em quatro 'casas' (%4x) e completado à esquerda com zeros (%04x), depois um TAB ('\t'), " bits: ", depois um inteiro (%d), seguido de um NEWLINE ('\n'). A variável a é exibida em dois formatos, decimal e hexadecimal para benefício dos humanos embora ela seja armazenada na memória em binário.

4) (K&R) Na representação em complemento de dois, "x &= (x-1)" apaga o bit menos significativo de x (bit mais à direita). Explique o porquê. Use esta otimização para escrever uma versão mais rápida de bitcount.<>