Operadores em C: aritméticos, lógicos e precedência

Operadores são os verbos de C: eles pegam valores e produzem novos. Existem cerca de 40 deles, mas uma dúzia cobre a maior parte do código, e dois desses têm armadilhas afiadas o bastante para merecerem suas próprias seções.

Operadores aritméticos

#include <stdio.h>

int main(void) {
    int a = 17, b = 5;

    printf("a + b  = %d\n", a + b);   /* 22 */
    printf("a - b  = %d\n", a - b);   /* 12 */
    printf("a * b  = %d\n", a * b);   /* 85 */
    printf("a / b  = %d\n", a / b);   /* 3  - divisao inteira! */
    printf("a %% b  = %d\n", a % b);  /* 2  - o resto */
    printf("-a     = %d\n", -a);      /* menos unario */
    return 0;
}

(%% na string de formato imprime um sinal de porcentagem literal - % sozinho começaria um especificador de formato.)

Os cinco operadores aritméticos binários são + - * / %, mais o - unário para negação e o +, que essencialmente não faz nada.

A armadilha da divisão inteira

a / b com dois inteiros faz divisão inteira e joga fora o resto. Não há arredondamento - o resultado é truncado em direção a zero.

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("7 / 2         = %d\n", total / count);          /* 3 */
    printf("7 / 2.0       = %f\n", total / 2.0);            /* 3.5 */
    printf("(double)7 / 2 = %f\n", (double)total / count);  /* 3.5 */

    double wrong = total / count;      /* a divisao acontece ANTES, como ints */
    printf("media errada = %f\n", wrong);   /* 3.000000 */
    return 0;
}

Esse último caso é o bug que sobrevive até a produção. Atribuir a um double não ajuda: a divisão total / count já está completa, e já é um int, antes de a atribuição acontecer. A correção é tornar um dos operandos de ponto flutuante dentro da expressão, normalmente com uma conversão de tipo.

Duas regras relacionadas: dividir por zero com inteiros é comportamento indefinido e tipicamente derruba o programa, e INT_MIN / -1 estoura.

O operador de módulo

% devolve o resto e funciona só com inteiros:

#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            printf("%d e par\n", i);
        } else {
            printf("%d e impar\n", i);
        }
    }

    int seconds = 3725;
    printf("\n%d segundos = %dh %dm %ds\n",
           seconds, seconds / 3600, (seconds % 3600) / 60, seconds % 60);
    return 0;
}

Testar x % 2 == 0 para saber se é par e usar % n para dar a volta em um índice de array são os dois usos do dia a dia.

Com números negativos, o % de C segue o sinal do dividendo:

#include <stdio.h>

int main(void) {
    printf(" 7 %% 3 = %d\n",  7 % 3);   /*  1 */
    printf("-7 %% 3 = %d\n", -7 % 3);   /* -1, nao 2 */
    printf(" 7 %% -3 = %d\n", 7 % -3);  /*  1 */
    return 0;
}

Então x % 2 == 1 é um teste quebrado para números ímpares quando x pode ser negativo - -7 % 2 é -1. Use x % 2 != 0 no lugar.

Para restos de ponto flutuante, % é erro de compilação; use fmod() da math.h.

Atribuição e atribuição composta

= guarda um valor. As formas compostas combinam uma operação com o armazenamento:

#include <stdio.h>

int main(void) {
    int x = 10;

    x += 5;   printf("x += 5   -> %d\n", x);   /* 15 */
    x -= 3;   printf("x -= 3   -> %d\n", x);   /* 12 */
    x *= 2;   printf("x *= 2   -> %d\n", x);   /* 24 */
    x /= 4;   printf("x /= 4   -> %d\n", x);   /* 6  */
    x %= 4;   printf("x %%= 4   -> %d\n", x);  /* 2  */
    return 0;
}

x += 5 significa x = x + 5, mas avalia x uma única vez - o que importa quando o alvo é algo como arr[compute_index()].

A atribuição é ela mesma uma expressão que devolve o valor atribuído, e é por isso que a = b = c = 0 funciona (ela atribui da direita para a esquerda) e por que o erro de = no lugar de == compila silenciosamente.

Incremento e decremento

++ soma um, -- subtrai um. Cada um vem em uma forma prefixa e uma pós-fixa:

#include <stdio.h>

int main(void) {
    int i = 5;
    int a = i++;    /* a recebe 5 (o valor antigo), depois i vira 6 */
    printf("pos-fixo: a = %d, i = %d\n", a, i);

    int j = 5;
    int b = ++j;    /* j vira 6 primeiro, depois b recebe 6 */
    printf("prefixo:  b = %d, j = %d\n", b, j);

    int k = 5;
    k++;            /* como instrucao isolada, identico a ++k */
    printf("instrucao: k = %d\n", k);
    return 0;
}

Como instrução isolada os dois são intercambiáveis, e i++ é a escolha convencional no cabeçalho de um for por nenhuma razão mais profunda do que a tradição.

O que você não pode fazer é usar uma variável mais de uma vez em uma expressão na qual ela também é modificada:

int i = 5;
int x = i++ + i++;      /* comportamento indefinido */
arr[i] = i++;           /* comportamento indefinido */
printf("%d %d", i++, i);/* comportamento indefinido */

C não define a ordem em que essas subexpressões são avaliadas, então o resultado não é meramente não especificado - o comportamento do programa inteiro é indefinido. Separe a instrução em duas e a ambiguidade desaparece.

Operadores de comparação

São seis, e todos produzem um int: 1 para verdadeiro e 0 para falso.

#include <stdio.h>

int main(void) {
    int a = 5, b = 8;

    printf("a == b : %d\n", a == b);   /* 0 */
    printf("a != b : %d\n", a != b);   /* 1 */
    printf("a <  b : %d\n", a <  b);   /* 1 */
    printf("a >  b : %d\n", a >  b);   /* 0 */
    printf("a <= 5 : %d\n", a <= 5);   /* 1 */
    printf("a >= 9 : %d\n", a >= 9);   /* 0 */
    return 0;
}

O resultado ser um int comum em vez de um tipo booleano dedicado é uma característica definidora de C - veja booleanos em C para o que decorre disso, incluindo o bug de = contra ==.

Dois erros de comparação são específicos de C. Encadear não funciona do jeito que a matemática sugere: if (1 < x < 10) é sempre verdadeiro, porque 1 < x avalia para 0 ou 1 e então isso é comparado com 10. Escreva if (x > 1 && x < 10). E comparar strings com == compara ponteiros, não texto - use strcmp da string.h.

Operadores lógicos

#include <stdio.h>

int main(void) {
    int age = 25;
    int has_license = 1;

    if (age >= 18 && has_license) {
        printf("Pode dirigir\n");
    }

    if (age < 13 || age > 65) {
        printf("Ingresso com desconto\n");
    } else {
        printf("Preco cheio\n");
    }

    printf("!has_license = %d\n", !has_license);   /* 0 */
    printf("!0 = %d\n", !0);                       /* 1 */
    return 0;
}

&& é E, || é OU, ! é NÃO. Os três tratam qualquer valor diferente de zero como verdadeiro.

Eles fazem curto-circuito: && para assim que um operando é falso, e || para assim que um é verdadeiro. O resto nunca é avaliado, o que não é só uma otimização - é uma garantia em que você pode confiar por segurança:

#include <stdio.h>

int is_safe(int *p) {
    /* Se p for NULL, *p nunca e avaliado - o && para antes. */
    return p != NULL && *p > 0;
}

int main(void) {
    int value = 7;
    printf("com um ponteiro real: %d\n", is_safe(&value));
    printf("com NULL:             %d\n", is_safe(NULL));
    return 0;
}

Troque a ordem desses dois testes e a chamada com NULL desreferencia um ponteiro nulo e derruba o programa. Proteja primeiro, use depois - a ordem em uma cadeia de && faz parte da lógica.

O operador condicional

O único operador de três operandos de C escolhe entre dois valores:

#include <stdio.h>

int main(void) {
    int a = 12, b = 30;

    int max = (a > b) ? a : b;
    printf("max = %d\n", max);

    printf("%d item%s\n", a, (a == 1) ? "" : "s");
    return 0;
}

condicao ? valor_se_verdadeiro : valor_se_falso. É uma expressão, então cabe onde uma instrução if não cabe - dentro de um argumento de printf, em um inicializador. Mantenha-o curto; condicionais aninhados se tornam ilegíveis rapidamente.

Operadores bit a bit, brevemente

Estes trabalham sobre os bits individuais de um inteiro:

#include <stdio.h>

int main(void) {
    unsigned int a = 12;   /* 1100 em binario */
    unsigned int b = 10;   /* 1010 */

    printf("a & b  = %u\n", a & b);    /* 8  - 1000, E */
    printf("a | b  = %u\n", a | b);    /* 14 - 1110, OU */
    printf("a ^ b  = %u\n", a ^ b);    /* 6  - 0110, XOR */
    printf("~a     = %u\n", ~a);       /* NAO - inverte cada bit */
    printf("a << 2 = %u\n", a << 2);   /* 48 - desloca para cima, multiplica por 4 */
    printf("a >> 2 = %u\n", a >> 2);   /* 3  - desloca para baixo, divide por 4 */
    return 0;
}

Eles são usados para flags, máscaras e registradores de hardware. Dois cuidados: & e | não são && e || (eles não fazem curto-circuito e operam bit a bit), e deslocar um valor com sinal ou deslocar por mais do que a largura do tipo é indefinido. Use tipos sem sinal para trabalho com bits.

Precedência

Quando uma expressão não tem parênteses, esta tabela decide o que se associa a quê. Maior precedência primeiro:

As consequências práticas:

a + b * c       /* significa a + (b * c) */
a < b == c < d  /* significa (a < b) == (c < d) - raramente o que voce queria */
x & 1 == 0      /* significa x & (1 == 0), ou seja x & 0 - um bug classico */
*p++            /* significa *(p++) - desreferencia p, depois avanca */

Essa terceira linha vale a pena memorizar: == se associa mais forte que &, então testes de máscara de bits precisam de parênteses - (x & 1) == 0.

Ninguém lembra dos quinze níveis, e ninguém precisa. Aprenda que * ganha de +, que comparações ganham de && que ganha de ||, e que todo o resto leva parênteses:

if ((flags & MASK) != 0 && (count > 0 || force)) { ... }

Essa linha tem parênteses redundantes e é melhor por causa deles.