C++: Visão Geral dos Operadores

Última atualização: 2026-08-26

Na Aula 03 aprendemos como armazenar dados usando variáveis.

Mas apenas armazenar dados não é suficiente — precisamos ser capazes de realizar operações com eles, como aritmética, comparações e julgamentos lógicos.

É para isso que servem os operadores. Assim como +, -, ×, ÷ na matemática, C++ tem seu próprio conjunto de operadores.

1. Categorias de Operadores

Os operadores de C++ podem ser divididos em várias categorias principais:

2. Operadores Aritméticos

(1) 2.1 Cinco Operadores Aritméticos Básicos

💡 Ponto-chave: A armadilha do operador /

#include <iostream>

int main() {
 int a = 10;
 int b = 3;
 
 std::cout << "10 / 3 = " << a / b << std::endl; // Exibe 3 (divisão inteira, parte decimal descartada)
 
 double c = 10.0;
 double d = 3.0;
 std::cout << "10.0 / 3.0 = " << c / d << std::endl; // Exibe 3.33333
 
 return 0;
}

Regras:

• Quando dois inteiros são divididos, o resultado ainda é inteiro (parte decimal é descartada)
• Se um dos operandos for ponto flutuante, o resultado é ponto flutuante

(2) 2.2 O Operador de Módulo %

% calcula o "resto":

#include <iostream>

int main() {
 std::cout << "10 % 3 = " << 10 % 3 << std::endl; // 1
 std::cout << "20 % 7 = " << 20 % 7 << std::endl; // 6
 std::cout << "5 % 5 = " << 5 % 5 << std::endl; // 0
 
 // Verificar par/ímpar
 int num = 7;
 if (num % 2 == 0) {
 std::cout << num << " is Even" << std::endl;
 } else {
 std::cout << num << " is Odd" << std::endl;
 }
 
 return 0;
}

💡 Dica: % só pode ser usado com inteiros, não com pontos flutuantes (10.5 % 3 causará erro).

3. Operadores Relacionais

Operadores relacionais são usados para comparar dois valores, retornando true ou false.

(1) 3.1 Seis Operadores Relacionais

💡 Ponto-chave: Não escreva = em vez de ==!

int age = 18;

if (age = 20) { // ❌ Erro: isto é atribuição, não comparação!
 std::cout << "An adult" << std::endl;
}
// O código acima sempre exibe "An adult", porque age = 20 atribui 20 a age, 
// depois verifica se age é verdadeiro (não-zero), o que é sempre verdade

Jeito correto:

if (age == 20) { // ✅ Correto: isto é comparação
 std::cout << "Exactly 20 years old" << std::endl;
}

💡 Técnica anti-bug: Coloque a constante do lado esquerdo — se você acidentalmente escrever = causará erro de compilação:

if (20 = age) { // ❌ Erro de compilação: não pode atribuir a uma constante
if (20 == age) { // ✅ Correto

4. Operadores Lógicos

Operadores lógicos são usados para combinar múltiplas condições.

(1) 4.1 Três Operadores Lógicos

▶ Exemplo 1: Verificador de Ano Bissexto (Dificuldade ⭐)

#include <iostream>

int main() {
 int year;
 std::cout << "Please enter a year: ";
 std::cin >> year;
 
 // Regra de ano bissexto: divisível por 4 mas não por 100, OU divisível por 400
 bool isLeapYear = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
 
 if (isLeapYear) {
 std::cout << year << " is a leap year" << std::endl;
 } else {
 std::cout << year << " is not a leap year" << std::endl;
 }
 
 return 0;
}

Saída:

Please enter a year: 
 is a leap year
 is not a leap year

Resultado da execução:

Please enter a year: 2024
2024 is a leap year

(2) 4.2 Avaliação de Curto-circuito

C++ tem um mecanismo de "curto-circuito":

• &&: Se o lado esquerdo for falso, o lado direito não será executado (porque o resultado já está determinado como falso)
• ||: Se o lado esquerdo for verdadeiro, o lado direito não será executado (porque o resultado já está determinado como verdadeiro)

#include <iostream>

int main() {
 int x = 5;
 
 // Exemplo de curto-circuito
 if (x > 10 && (x = 100)) { // x > 10 é falso, então x = 100 não será executado
 // ...
 }
 
 std::cout << "x = " << x << std::endl; // Exibe x = 5 (não mudou para 100)
 
 return 0;
}

💡 Dica: Usando avaliação de curto-circuito, você pode colocar "condições mais prováveis de serem falsas" do lado esquerdo de && para melhorar a eficiência do programa.

5. Operadores de Atribuição

(1) 5.1 Operador de Atribuição Básico =

int x = 5; // Atribui 5 a x

(2) 5.2 Operadores de Atribuição Composta

Exemplo:

#include <iostream>

int main() {
 int x = 10;
 
 x += 5; // x passa a 15
 x -= 3; // x passa a 12
 x *= 2; // x passa a 24
 x /= 4; // x passa a 6
 x %= 4; // x passa a 2
 
 std::cout << "x = " << x << std::endl; // Exibe x = 2
 
 return 0;
}

💡 Dica: Operadores de atribuição composta não são apenas mais concisos, em alguns casos o compilador pode gerar código mais eficiente.

6. Operadores de Incremento e Decremento

++ e -- são os operadores assinatura de C++ (C++ ganhou seu nome deles).

(1) 6.1 Uso Básico

▶ Exemplo 2: Pré-incremento vs Pós-incremento (Dificuldade ⭐⭐)

#include <iostream>

int main() {
 int a = 5;
 int b = 5;
 
 std::cout << "a = " << a << ", ++a = " << ++a << ", a = " << a << std::endl;
 // Saída: a = 5, ++a = 6, a = 6
 
 std::cout << "b = " << b << ", b++ = " << b++ << ", b = " << b << std::endl;
 // Saída: b = 5, b++ = 5, b = 6
 
 return 0;
}

Saída:

a = 5, ++a = 6, a = 6
b = 5, b++ = 5, b = 6

💡 Truque de memorização:

• ++x: Incrementa primeiro, depois usa (x é incrementado primeiro, depois o novo valor é usado)
• x++: Usa primeiro, depois incrementa (o valor original é usado primeiro, depois x é incrementado)

(2) 6.2 Uso Comum

for (int i = 0; i < 10; i++) { // Aqui i++ e ++i têm o mesmo efeito
 // ...
}

int x = 5;
int y = x++; // y = 5, x = 6
int z = ++x; // x incrementa para 7 primeiro, z = 7

💡 Recomendação: Se não há necessidade especial, prefira ++i em vez de i++ — para tipos personalizados (cobertos mais tarde), ++i pode ser mais eficiente.

7. Precedência de Operadores

Quando uma expressão contém múltiplos operadores, C++ determina a ordem de avaliação baseada na precedência.

(1) 7.1 Tabela de Precedência (Parcial)

▶ Exemplo 3: Impacto da Precedência (Dificuldade ⭐⭐)

#include <iostream>

int main() {
 int result1 = 5 + 3 * 2; // Primeiro 3 * 2 = 6, depois 5 + 6 = 11
 int result2 = (5 + 3) * 2; // Primeiro 5 + 3 = 8 nos parênteses, depois 8 * 2 = 16
 
 std::cout << "5 + 3 * 2 = " << result1 << std::endl; // 11
 std::cout << "(5 + 3) * 2 = " << result2 << std::endl; // 16
 
 return 0;
}

Saída:

5 + 3 * 2 = 11
(5 + 3) * 2 = 16

💡 Regra de ouro: Se você tem dúvida sobre a precedência, use parênteses! Parênteses não apenas garantem corretude mas também tornam o código mais legível.

8. Prática: Programa de Classificação de Notas

▶ Exemplo 4: Classificação de Notas Baseada na Pontuação (Dificuldade ⭐⭐)

#include <iostream>

int main() {
 int score;
 std::cout << "Please enter your score (0-100): ";
 std::cin >> score;
 
 if (score >= 90 && score <= 100) {
 std::cout << "Excellent! Grade: A" << std::endl;
 } else if (score >= 80 && score < 90) {
 std::cout << "Good! Grade: B" << std::endl;
 } else if (score >= 70 && score < 80) {
 std::cout << "Medium! Grade: C" << std::endl;
 } else if (score >= 60 && score < 70) {
 std::cout << "Pass! Grade: D" << std::endl;
 } else if (score >= 0 && score < 60) {
 std::cout << "Not Pass! Grade: F" << std::endl;
 } else {
 std::cout << "Error: Score must be between 0-100!" << std::endl;
 }
 
 return 0;
}

Saída:

Please enter your score (0-100): 
Excellent! Grade: A
Good! Grade: B
Medium! Grade: C
Pass! Grade: D
Not Pass! Grade: F
Error: Score must be between 0-100!

Resultado da execução:

Please enter your score (0-100): 85
Good! Grade: B

❓ Perguntas Frequentes

P: Por que 10 / 3 = 3 em vez de 3.3333? R: Porque ambos os operandos são inteiros, C++ realiza divisão inteira (descartando a parte decimal). Para um resultado decimal, torne pelo menos um operando ponto flutuante: 10.0 / 3 ou 10 / 3.0 resulta em 3.33333.

P: % funciona com números negativos? R: Sim, mas o sinal do resultado depende do dividendo (padrão C++11). É recomendado usar % apenas com inteiros positivos para evitar armadilhas. Por exemplo, (-10) % 3 resulta em -1. P: Por que não posso escrever 5 < x < 10? R: Isso é notação matemática mas C++ não a suporta. O jeito correto é conectar duas condições com E lógico: if (5 < x && x < 10). P: Qual a diferença real entre i++ e ++i? R: i++ (pós-incremento) retorna o valor original depois incrementa; ++i (pré-incremento) incrementa primeiro depois retorna o novo valor. Para tipos básicos como int não há diferença de desempenho, mas para iteradores e outros tipos personalizados ++i pode ser mais eficiente (não precisa salvar o valor original). Recomendação: prefira ++i quando não há necessidade especial.

📖 Resumo

• C++ tem cinco grandes categorias de operadores: aritméticos, relacionais, lógicos, de atribuição e incremento/decremento
• Divisão inteira descarta a parte decimal; para obter resultado decimal, torne pelo menos um operando ponto flutuante
• Não escreva = em vez de ==, ou terá bugs grandes
• ++i incrementa primeiro depois usa o valor; i++ usa o valor primeiro depois incrementa
• Se você tem dúvida sobre precedência de operadores, use parênteses!
• Operadores lógicos têm comportamento de curto-circuito, que pode melhorar a eficiência

📝 Exercícios

1. Básico (Dificuldade ⭐): Escreva um programa que permita ao usuário digitar dois inteiros, depois exiba sua soma, diferença, produto, quociente e resto.

Please enter the first integer: 10
Please enter the second integer: 3
Sum: 13
Difference: 7
Product: 30
Quotient: 3
Remainor: 1

2. Intermediário (Dificuldade ⭐⭐): Escreva um programa que permita ao usuário digitar um número de três dígitos (ex: 365), depois exiba cada dígito separadamente (centenas, dezenas, unidades).

Please enter a three-digit number: 365
Hundreds: 3
Tens: 6
Ones: 5

(Dica: use os operadores / e %)

3. Desafio (Dificuldade ⭐⭐⭐): Escreva um programa que implemente um jogo de "adivinhe o número":
4. O programa gera um número aleatório de 1-100 (dica: use % 100 + 1 para mapear números aleatórios para 1-100)
5. Deixe o usuário adivinhar o número
6. Se o palpite for alto, dica "Too high!"
7. Se o palpite for baixo, dica "Too low!"
8. Se o palpite estiver correto, dica "Congratulations, you got it!"
9. (Avançado: conte quantas tentativas o usuário fez)

• Cinco grandes categorias de operadores C++: aritméticos, relacionais, lógicos, de atribuição, incremento/decremento
• Divisão inteira descarta a parte decimal; converta operandos para ponto flutuante para resultados decimais
• Operadores relacionais retornam valores bool; note a diferença entre == e =
• Operadores lógicos têm comportamento de curto-circuito
• Quando em dúvida sobre precedência, use parênteses

9. 🚀 Próximo Passo

Agora que você aprendeu operadores, a seguir vamos aprender instruções condicionais (if-else) (Aula 05) — permitindo que programas tomem decisões e executem código diferente baseado em diferentes condições.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós