C Operadores

Esta é a página de consulta rápida dos operadores do C: os símbolos que fazem contas, comparam, combinam condições, mexem em bits e em ponteiros. Primeiro vem a tabela completa de precedência (quem é calculado primeiro); depois, uma tabela por grupo, com o exemplo e a saída real; no fim, as armadilhas. Para aprender com calma, comece pela aula Operadores Aritméticos e siga até Precedência.

Todas as saídas foram produzidas de verdade: no gcc 15.2 da máquina da Ana (pasta ~/c/ref, comando gcc -std=c23 -Wall -Wextra) e no editor do guia (Clang em WebAssembly). Os operadores dão o mesmo resultado nos dois; só as mensagens de aviso mudam.

Atalhos: Precedência · Aritméticos · Atribuição · ++ e -- · Comparação · Lógicos · Bits · Ponteiros e membros · Outros · Armadilhas · Experimente

Tabela de precedência e associatividade

A precedência diz qual operador "pega" seus valores primeiro, como na matemática: em 2 + 3 * 4, o * vem antes, e o resultado é 14. A associatividade decide entre operadores da mesma linha: da esquerda para a direita (10 - 3 - 2 = (10 - 3) - 2 = 5) ou da direita para a esquerda (a = b = 0 = a = (b = 0)).

Na tabela, a linha 1 é a mais forte (calculada primeiro) e a 15, a mais fraca. Na dúvida, use parênteses: eles sempre ganham, e deixam o código mais claro.

Precedência não é ordem de execução. Ela diz como a expressão é agrupada, não qual parte roda primeiro. Em f() + g() * h(), a multiplicação é agrupada antes, mas o C não diz qual das três funções é chamada primeiro. Só &&, ||, ?: e a vírgula garantem a ordem (da esquerda para a direita).

Aritméticos

Todas as tabelas daqui até Outros foram medidas com um só programa, ops.c (com int a = 17, b = 5;). Ele está no fim da seção, com a saída completa.

Atribuição

Toda atribuição também é um valor (o valor guardado). É por isso que a = b = 0 funciona, e é por isso que if (idade = 18) compila (veja Armadilhas).

++ e --

Sozinhos numa linha (i++; ou ++i;), os dois fazem a mesma coisa. Nunca use a mesma variável duas vezes numa expressão que a muda: i = i++ + 1 é comportamento indefinido (veja Armadilhas).

Comparação

O resultado é um int: 1 (verdadeiro) ou 0 (falso). Para strings, use strcmp (veja); para double, uma tolerância.

Lógicos

Bits

Com 12 = 0b1100 e 10 = 0b1010:

Use unsigned com operadores de bits. Com int, 1 << 31 é comportamento indefinido (deu -2147483648 nos dois, sem aviso); com 1u << 31, é 2147483648. Deslocar por um número de casas maior ou igual ao tamanho do tipo também é indefinido: 1 << n com n = 32 deu 1 nos dois, e não 0.

Ponteiros, arrays e membros

Com int v[3] = {10, 20, 30}; int *p = v; e struct ponto { int x, y; } pt = {3, 4}, *pp = &pt;:

Outros operadores

Vírgula como operador e vírgula que separa argumentos são coisas diferentes: em printf("%d %d", a, b), as vírgulas só separam.

O programa das tabelas

#include <stdio.h>

int main(void) {
    int a = 17, b = 5;
    printf("aritméticos: %d %d %d %d %d\n", a + b, a - b, a * b, a / b, a % b);
    printf("negativos: %d %d %d %d\n", -17 / 5, -17 % 5, 17 / -5, 17 % -5);
    printf("com double: %.2f %.2f\n", 17 / 5.0, (double)a / b);
    printf("unários: %d %d\n", -a, +a);
    int x = 10;
    x += 5;  printf("x += 5  -> %d\n", x);
    x -= 3;  printf("x -= 3  -> %d\n", x);
    x *= 2;  printf("x *= 2  -> %d\n", x);
    x /= 5;  printf("x /= 5  -> %d\n", x);
    x %= 3;  printf("x %%= 3  -> %d\n", x);
    x <<= 4; printf("x <<= 4 -> %d\n", x);
    x >>= 1; printf("x >>= 1 -> %d\n", x);
    x &= 6;  printf("x &= 6  -> %d\n", x);
    x |= 1;  printf("x |= 1  -> %d\n", x);
    x ^= 3;  printf("x ^= 3  -> %d\n", x);
    int i = 5;
    int pos = i++;
    printf("i++: valor %d, i agora %d\n", pos, i);
    int pre = ++i;
    printf("++i: valor %d, i agora %d\n", pre, i);
    printf("comparação: %d %d %d %d %d %d\n", a == b, a != b, a < b, a > b, a <= 17, a >= 18);
    printf("lógicos: %d %d %d %d\n", 1 && 0, 1 || 0, !0, !5);
    printf("bits: %d %d %d %d %d %d\n", 12 & 10, 12 | 10, 12 ^ 10, ~12, 1 << 4, 200 >> 3);
    printf("ternário: %s\n", a > b ? "a é maior" : "b é maior");
    int v[3] = {10, 20, 30};
    int *p = v;
    printf("ponteiros: %d %d %d %d\n", *p, p[2], *(p + 1), (int)(&v[2] - p));
    struct ponto { int x, y; } pt = {3, 4}, *pp = &pt;
    printf("membros: %d %d\n", pt.x, pp->y);
    printf("sizeof: %zu %zu %zu\n", sizeof a, sizeof(double), sizeof v);
    printf("alignof(double): %zu\n", alignof(double));
    int k = (a = 1, b = 2, a + b);
    printf("vírgula: %d\n", k);
    typeof(a) c = 9;
    printf("typeof: %d\n", c);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra ops.c -o ops
$ ./ops
aritméticos: 22 12 85 3 2
negativos: -3 -2 -3 2
com double: 3.40 3.40
unários: -17 17
x += 5  -> 15
x -= 3  -> 12
x *= 2  -> 24
x /= 5  -> 4
x %= 3  -> 1
x <<= 4 -> 16
x >>= 1 -> 8
x &= 6  -> 0
x |= 1  -> 1
x ^= 3  -> 2
i++: valor 5, i agora 6
++i: valor 7, i agora 7
comparação: 0 1 0 1 1 0
lógicos: 0 1 1 0
bits: 8 14 6 -13 16 25
ternário: a é maior
ponteiros: 10 30 20 2
membros: 3 4
sizeof: 4 8 12
alignof(double): 8
vírgula: 3
typeof: 9

A saída do editor é idêntica, linha por linha.

Armadilhas

Este programa compila (no gcc) e roda, mas quase nenhuma linha faz o que parece. O -Wall avisa de todas:

#include <stdio.h>

int main(void) {
    int flags = 6;
    if (flags & 4 == 4) printf("bit 2 ligado\n");
    int x = 1 << 2 + 1;
    printf("1 << 2 + 1 = %d\n", x);
    int idade = 15;
    if (idade = 18) printf("maior de idade (idade = %d)\n", idade);
    int a = 2, b = 3;
    if (a < b < 1) printf("a < b < 1 é verdade?!\n");
    int i = 1;
    i = i++ + 1;
    printf("i = %d\n", i);
    if (!a == 5) printf("nunca\n");
    printf("%d\n", a && b || 0 && 1);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra armadilhas.c -o armadilhas
armadilhas.c: In function ‘main’:
armadilhas.c:5:15: warning: suggest parentheses around comparison in operand of ‘&’ [-Wparentheses]
    5 |     if (flags & 4 == 4) printf("bit 2 ligado\n");
      |               ^
armadilhas.c:6:15: warning: suggest parentheses around ‘+’ inside ‘<<’ [-Wparentheses]
    6 |     int x = 1 << 2 + 1;
      |               ^~
armadilhas.c:9:9: warning: suggest parentheses around assignment used as truth value [-Wparentheses]
    9 |     if (idade = 18) printf("maior de idade (idade = %d)\n", idade);
      |         ^~~~~
armadilhas.c:11:11: warning: comparisons like ‘X<=Y<=Z’ do not have their mathematical meaning [-Wparentheses]
   11 |     if (a < b < 1) printf("a < b < 1 é verdade?!\n");
      |         ~~^~~
armadilhas.c:13:7: warning: operation on ‘i’ may be undefined [-Wsequence-point]
   13 |     i = i++ + 1;
      |     ~~^~~~~~~~~
armadilhas.c:15:12: warning: comparison of constant ‘5’ with boolean expression is always false [-Wbool-compare]
   15 |     if (!a == 5) printf("nunca\n");
      |            ^~
armadilhas.c:15:12: warning: logical not is only applied to the left hand side of comparison [-Wlogical-not-parentheses]
armadilhas.c:15:9: note: add parentheses around left hand side expression to silence this warning
   15 |     if (!a == 5) printf("nunca\n");
      |         ^~
      |         ( )
armadilhas.c:16:22: warning: suggest parentheses around ‘&&’ within ‘||’ [-Wparentheses]
   16 |     printf("%d\n", a && b || 0 && 1);
      |                    ~~^~~~
$ ./armadilhas
1 << 2 + 1 = 8
maior de idade (idade = 18)
i = 2
1

Experimente

#include <stdio.h>

int main(void) {
    int a = 6, b = 3, c = 2;
    printf("%d\n", a + b * c);
    printf("%d\n", a / b * c);
    printf("%d\n", a - b - c);
    printf("%d\n", a % 4 + b);
    printf("%d\n", -a / 4);
    printf("%d\n", a > b && b > c);
    printf("%d\n", a == 6 || b++ == 99);
    printf("b depois: %d\n", b);
    printf("%d\n", a > b ? a : b);
    return 0;
}

#include <stdio.h>

int main(void) {
    int flags = 6;
    if (flags & 4 == 4) {
        printf("bit 2 ligado\n");
    }
    return 0;
}

#include <stdio.h>

int main(void) {
    int flags = 6;
    if ((flags & 4) == 4) {
        printf("bit 2 ligado\n");
    }
    return 0;
}

Resumo

• Precedência, do mais forte ao mais fraco: pós-fixos (a++ f() v[i] . ->) → unários (! ~ - * & sizeof cast) → * / % → + - → << >> → < <= > >= → == != → & → ^ → | → && → || → ?: → atribuições → ,.
• Da direita para a esquerda: os unários, o ?: e as atribuições. O resto, da esquerda para a direita.
• Divisão de inteiros corta a parte decimal; % tem o sinal do primeiro número.
• && e || param assim que sabem a resposta (curto-circuito).
• Com &, |, ^ e <<, use parênteses. = guarda, == compara. Não mude a mesma variável duas vezes numa expressão.