Aula 04 – Operadores Aritméticos e Relacionais

Operadores Aritméticos

Os operadores aritméticos realizam as quatro operações matemáticas básicas, mais o resto da divisão. Em C, eles funcionam de forma idêntica ao Java para tipos numéricos:

#include <stdio.h>

int main() {
    int a = 10, b = 3;

    printf("Adição:       %d\n", a + b);  // 13
    printf("Subtração:    %d\n", a - b);  // 7
    printf("Multiplicação:%d\n", a * b);  // 30
    printf("Divisão:      %d\n", a / b);  // 3  (divisão inteira)
    printf("Módulo:       %d\n", a % b);  // 1  (resto de 10 ÷ 3)

    return 0;
}

int   a = 7, b = 2;
printf("%d\n",   a / b);         // 3   — divisão inteira
printf("%.1f\n", (double)a / b); // 3.5 — cast força divisão real
printf("%.1f\n", 7.0 / b);       // 3.5 — literal 7.0 já é double

O operador módulo (%)

O operador % retorna o resto da divisão inteira. Só funciona com inteiros (int, long, etc.) — não é válido com float ou double. Ele tem usos clássicos muito importantes:

#include <stdio.h>

int main() {
    // Verificar se um número é par ou ímpar
    int n = 17;
    if (n % 2 == 0)
        printf("%d é par\n", n);
    else
        printf("%d é ímpar\n", n);   // imprime este

    // Limitar um valor a um intervalo (ex: relógio circular)
    int segundos = 65;
    printf("Segundos restantes: %d\n", segundos % 60);  // 5

    // Verificar divisibilidade
    int x = 100;
    if (x % 5 == 0)
        printf("%d é divisível por 5\n", x);  // imprime este

    return 0;
}

Operadores de Atribuição Composta

C (assim como Java) oferece atalhos que combinam uma operação aritmética com a atribuição do resultado à própria variável. Eles tornam o código mais conciso e são amplamente usados em loops:

x = x + n, x+=n, o novo x é igual ao antigo x + n

x = x - n, x-=n, o novo x é igual ao antigo x - n

x = x * n, x*=n, o novo x é igual ao antigo x * n

x = x / n, x/=n, o novo x é igual ao antigo x / n

x = x % n, x%=n, o novo x é igual ao antigo x % n

#include <stdio.h>

int main() {
    int saldo = 1000;

    saldo += 500;   // depósito
    printf("Após depósito:  %d\n", saldo);  // 1500

    saldo -= 200;   // saque
    printf("Após saque:     %d\n", saldo);  // 1300

    saldo *= 2;     // dobra o saldo
    printf("Após dobrar:    %d\n", saldo);  // 2600

    saldo /= 4;     // divide por 4
    printf("Após dividir:   %d\n", saldo);  // 650

    return 0;
}

Incremento e Decremento

Os operadores ++ e -- somam ou subtraem 1 de uma variável. São usados extensivamente em loops e existem em duas formas: pré-fixada e pós-fixada.

#include <stdio.h>

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

    // Pós-incremento: usa 5, depois vira 6
    printf("a++: %d\n", a++);  // imprime 5
    printf("a agora: %d\n", a); // imprime 6

    // Pré-incremento: vira 6 primeiro, depois usa 6
    printf("++b: %d\n", ++b);  // imprime 6
    printf("b agora: %d\n", b); // imprime 6

    return 0;
}

Operadores Relacionais

Os operadores relacionais comparam dois valores e retornam um resultado booleano — em C, esse resultado é um inteiro: 1 para verdadeiro e 0 para falso. Eles são a base de toda estrutura de decisão (if) e de repetição (while, for).

#include <stdio.h>

int main() {
    int x = 10, y = 20;

    printf("x == y: %d\n", x == y);  // 0 (falso)
    printf("x != y: %d\n", x != y);  // 1 (verdadeiro)
    printf("x <  y: %d\n", x < y);   // 1 (verdadeiro)
    printf("x >  y: %d\n", x > y);   // 0 (falso)
    printf("x <= y: %d\n", x <= y);  // 1 (verdadeiro)
    printf("x >= y: %d\n", x >= y);  // 0 (falso)

    return 0;
}

int x = 5;
if (x = 10)    // ⚠ ATRIBUI 10 a x e testa se 10 é verdadeiro (sempre true!)
    printf("nunca falso\n");

if (x == 10)   // ✓ COMPARA x com 10
    printf("x é dez\n");

Precedência de Operadores

Quando vários operadores aparecem em uma mesma expressão, o C define uma ordem de avaliação — a precedência — semelhante à matemática (multiplicação antes da adição). Operadores com a mesma precedência são avaliados da esquerda para a direita (associatividade).

#include <stdio.h>

int main() {
    int resultado;

    resultado = 2 + 3 * 4;
    printf("%d\n", resultado);   // 14 — * antes de +

    resultado = (2 + 3) * 4;
    printf("%d\n", resultado);   // 20 — () força a adição primeiro

    resultado = 10 - 4 - 2;
    printf("%d\n", resultado);   // 4  — associatividade esquerda: (10-4)-2

    resultado = 10 > 5 + 3;
    printf("%d\n", resultado);   // 1  — 5+3=8, depois 10>8 = verdadeiro (1)

    return 0;
}

Funções Matemáticas: <math.h>

Para operações além das quatro básicas — como potência, raiz quadrada, seno, logaritmo — o C fornece a biblioteca <math.h>, equivalente à classe Math do Java:

#include <stdio.h>
#include <math.h>   // necessário para funções matemáticas

int main() {
    double x = 9.0;

    printf("Raiz de %.0f:     %.2f\n", x, sqrt(x));    // 3.00
    printf("2 elevado a 8:  %.0f\n",   pow(2, 8));     // 256
    printf("Teto de 4.3:    %.0f\n",   ceil(4.3));     // 5
    printf("Piso de 4.9:    %.0f\n",   floor(4.9));    // 4
    printf("|−7.5|:          %.1f\n",  fabs(-7.5));    // 7.5

    return 0;
}

Exemplo Completo: Calculadora de IMC

Vamos combinar operadores aritméticos e relacionais em um programa real — o cálculo do Índice de Massa Corporal (IMC):

#include <stdio.h>
#include <math.h>

int main() {
    double peso, altura, imc;

    printf("Digite seu peso (kg): ");
    scanf("%lf", &peso);

    printf("Digite sua altura (m): ");
    scanf("%lf", &altura);

    imc = peso / (altura * altura);   // fórmula do IMC

    printf("\nSeu IMC: %.2f\n", imc);

    if (imc < 18.5)
        printf("Classificação: Abaixo do peso\n");
    else if (imc < 25.0)
        printf("Classificação: Peso normal\n");
    else if (imc < 30.0)
        printf("Classificação: Sobrepeso\n");
    else
        printf("Classificação: Obesidade\n");

    return 0;
}

Operadores em C versus Java

Os operadores aritméticos e relacionais são praticamente idênticos nas duas linguagens. As diferenças estão nos detalhes de comportamento: