C# Operadores Aritméticos

Fazer contas é uma das coisas que o computador faz de melhor. No C#, as contas usam operadores: símbolos como + e * que pegam dois valores e produzem um resultado. Quatro deles você conhece da escola. O quinto, o %, é novo e muito útil. E a divisão guarda uma surpresa: 7 / 2 dá 3. Nesta aula você vai entender cada um, com as contas da lojinha da Ana.

Todos os programas desta aula foram rodados com o .NET 10 (C# 14) na máquina fictícia da Ana (usuária ana, computador notebook), na pasta ~/cs, com dotnet run arquivo.cs.

A ideia: a calculadora, com uma tecla a mais

Os operadores do C# são as teclas de uma calculadora: + soma, - subtrai, * multiplica (no teclado não há o ×) e / divide (não há o ÷). A tecla a mais é o %, que dá o resto da divisão, aquele número que sobrava na "conta armada" da escola.

Os valores dos dois lados de um operador se chamam operandos. Em a + b, o operador é + e os operandos são a e b. E o tipo dos operandos decide o tipo do resultado, como você vai ver na divisão.

1. Os cinco operadores

int a = 17;
int b = 5;
Console.WriteLine(a + b);
Console.WriteLine(a - b);
Console.WriteLine(a * b);
Console.WriteLine(a / b);
Console.WriteLine(a % b);

$ dotnet run arit1.cs
22
12
85
3          « 17 / 5 = 3, e não 3,4
2          « o resto: 17 = 5 × 3 + 2

O resultado de uma conta pode ir para uma variável, para o Console.WriteLine ou para outra conta. Os espaços em volta do operador não são obrigatórios (a+b funciona), mas o padrão do C# é usar um de cada lado: a + b.

Uma conta da lojinha

decimal precoCaderno = 12.90m;
decimal precoCaneta = 2.50m;
int cadernos = 3;
int canetas = 4;
decimal total = precoCaderno * cadernos + precoCaneta * canetas;
decimal pago = 100m;
decimal troco = pago - total;
Console.WriteLine($"Total: {total}");
Console.WriteLine($"Troco: {troco}");

$ dotnet run lojinha.cs
Total: 48,70
Troco: 51,30

3 cadernos de R$ 12,90 (38,70) mais 4 canetas de R$ 2,50 (10,00) dão 48,70; o troco de R$ 100 é 51,30. As multiplicações foram feitas antes da soma, como na matemática (seção 5). Dinheiro em decimal, como sempre (aula float, double e decimal).

2. A divisão inteira

Quando os dois lados da divisão são inteiros, o resultado também é inteiro: a parte depois da vírgula é jogada fora (não é arredondada). Se pelo menos um dos lados tem vírgula, a divisão é a de sempre:

Console.WriteLine(7 / 2);
Console.WriteLine(-7 / 2);
Console.WriteLine(7 % 2);
Console.WriteLine(-7 % 2);
Console.WriteLine(7 % -2);
Console.WriteLine(7.0 / 2);
Console.WriteLine(7 / 2.0);
Console.WriteLine(7m / 2);
Console.WriteLine(5.5 % 2);
Console.WriteLine(1 / 3);

$ dotnet run divint.cs
3
-3
1
-1
1
3,5
3,5
3,5
1,5
0

7 / 2 → 3 · -7 / 2 → -3

Dois int: divisão inteira. O corte é sempre em direção ao zero: -3,5 vira -3 (não -4).

7 % 2 → 1 · -7 % 2 → -1 · 7 % -2 → 1

O resto tem o sinal do número da esquerda. Vale a regra: (a / b) * b + a % b == a. Para -7: (-3) × 2 + (-1) = -7.

7.0 / 2 · 7 / 2.0 · 7m / 2

Basta um dos lados ser double (ou decimal) para a divisão ter vírgula: o outro lado é convertido antes (aula Conversão de Tipos).

5.5 % 2 → 1,5

O % também funciona com vírgula: 5,5 = 2 × 2 + 1,5.

1 / 3 → 0

A armadilha clássica: um terço, em inteiros, é zero.

A média que perdeu a vírgula

int nota1 = 7;
int nota2 = 8;
double media = (nota1 + nota2) / 2;
Console.WriteLine($"Média: {media}");

$ dotnet run mediaint.cs
Média: 7           « devia ser 7,5

A variável é double, mas a conta (nota1 + nota2) / 2 só tem int: é feita em inteiros (15 / 2 = 7) e só depois vai para a variável. Nenhum aviso. Há três consertos, todos fazendo um lado da divisão ter vírgula:

• (nota1 + nota2) / 2.0: escrever o número fixo com ponto;
• (double)(nota1 + nota2) / 2: converter um dos lados com um cast;
• declarar as notas como double desde o começo (o melhor, se notas podem ter vírgula).

int nota1 = 7;
int nota2 = 8;
double media = (nota1 + nota2) / 2;
Console.WriteLine($"Média: {media}");

int nota1 = 7;
int nota2 = 8;
double media = (nota1 + nota2) / 2.0;
Console.WriteLine($"Média: {media}");

3. O resto: %

O % parece estranho no começo, mas resolve vários problemas do dia a dia. Junto com a divisão inteira, ele "quebra" uma quantidade em partes:

int totalMinutos = 135;
int horas = totalMinutos / 60;
int minutos = totalMinutos % 60;
Console.WriteLine($"{totalMinutos} minutos = {horas} h {minutos} min");
int numero = 14;
Console.WriteLine($"{numero} % 2 = {numero % 2}");
int ovos = 50;
Console.WriteLine($"{ovos / 12} dúzias e {ovos % 12} ovos soltos");
int ano = 2026;
Console.WriteLine(ano % 10);

$ dotnet run restos.cs
135 minutos = 2 h 15 min
14 % 2 = 0
4 dúzias e 2 ovos soltos
6

totalMinutos / 60 · totalMinutos % 60

Quantas horas inteiras cabem em 135 minutos (2), e quantos minutos sobram (15). É o mesmo jeito de converter segundos em minutos, centavos em reais, dias em semanas.

numero % 2

O resto da divisão por 2 diz se o número é par (resto 0) ou ímpar (resto 1). Você vai usar isso com if: if (numero % 2 == 0).

ovos / 12 · ovos % 12

Quantas caixas de dúzia e quantos ovos sobram fora das caixas.

ano % 10

O resto por 10 é o último dígito do número. Por 100, os dois últimos.

Em inglês, o % se chama remainder ("resto") ou modulo. Não confunda com porcentagem: 50 % 10 é 0 (o resto), não "10% de 50". Porcentagem se faz com multiplicação: 50 * 0.10m.

4. Divisão por zero

Com inteiros, dividir por zero para o programa:

int pizzas = 8;
int pessoas = 0;
Console.WriteLine(pizzas / pessoas);

$ dotnet run divzeroi.cs
Unhandled exception. System.DivideByZeroException: Attempted to divide by zero.
   at Program.<Main>$(String[] args) in /home/ana/cs/divzeroi.cs:line 3
$ echo $?
134

System.DivideByZeroException é a "exceção de divisão por zero"; Attempted to divide by zero = "tentativa de dividir por zero"; e a última linha diz onde: divzeroi.cs, linha 3. O código de saída 134 é o de um programa que morreu com exceção. O % com zero à direita faz o mesmo, e o decimal também (aula float, double e decimal).

Se o zero está escrito direto no código, o compilador percebe antes:

int x = 10 / 0;
Console.WriteLine(x);

$ dotnet run divzeroconst.cs
/home/ana/cs/divzeroconst.cs(1,9): error CS0020: Divisão por zero constante

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

Com double, a divisão por zero não para o programa. O resultado é um valor especial:

double km = 150;
double litros = 0;
Console.WriteLine(km / litros);
Console.WriteLine(-km / litros);
Console.WriteLine(0.0 / litros);

$ dotnet run divzerodouble.cs
∞
-∞
NaN

Infinito (∞), menos infinito e NaN (Not a Number, "não é um número"). Em pt-BR, o .NET mostra o símbolo ∞. O programa segue, mas com um consumo de "infinitos quilômetros por litro". Em qualquer tipo, a solução é a mesma: confira o divisor antes de dividir, com if (litros != 0) (aula if e else).

5. A ordem das contas

Como na matemática, *, / e % são feitos antes de + e -. Entre operadores do mesmo grupo, a conta vai da esquerda para a direita. Os parênteses mudam a ordem:

Console.WriteLine(2 + 3 * 4);
Console.WriteLine((2 + 3) * 4);
Console.WriteLine(10 - 4 - 3);
Console.WriteLine(100 / 10 / 5);
Console.WriteLine(10 - 2 * 3 + 8 / 4);
Console.WriteLine(7 + 8 / 2);
Console.WriteLine((7 + 8) / 2.0);

$ dotnet run precedencia1.cs
14
20
3
2
6
11
7,5

2 + 3 * 4 → 14

Primeiro 3 × 4 = 12, depois 2 + 12.

(2 + 3) * 4 → 20

Os parênteses vêm primeiro: 5 × 4.

10 - 4 - 3 → 3 · 100 / 10 / 5 → 2

Mesmo grupo: da esquerda para a direita. (10 - 4) - 3 e (100 / 10) / 5.

10 - 2 * 3 + 8 / 4 → 6

2 × 3 = 6 e 8 / 4 = 2; depois 10 - 6 + 2.

7 + 8 / 2 → 11

O erro mais comum na média: só o 8 foi dividido. A média de 7 e 8 é (7 + 8) / 2.0.

Na dúvida, use parênteses: eles nunca atrapalham e deixam a intenção clara. A tabela completa da ordem de todos os operadores está em Precedência.

O sinal de menos sozinho

O - também funciona com um operando só, na frente de um valor: troca o sinal. É o "menos unário":

int temperatura = 5;
int negativa = -temperatura;
Console.WriteLine(negativa);
Console.WriteLine(-negativa);
Console.WriteLine(+temperatura);

$ dotnet run unario.cs
-5
5
5

O + unário existe, mas não muda nada. E os operadores ++ e --, que somam e subtraem 1, têm aula própria: ++ e --.

6. Duas pegadinhas

^ não é potência

Em calculadoras e planilhas, 2^3 é "2 elevado a 3". No C#, não:

Console.WriteLine(2 ^ 3);
Console.WriteLine(Math.Pow(2, 3));
Console.WriteLine(5 * 5);
Console.WriteLine(Math.Sqrt(16));

$ dotnet run potencia.cs
1          « não é 8!
8
25
4

O ^ do C# é o "ou exclusivo" de bits, um operador de outro assunto (aula Operadores Lógicos). Ele compila sem aviso e dá um número sem relação com a potência. O C# não tem operador de potência: use Math.Pow(base, expoente) ("potência"), que devolve um double, ou multiplique (5 * 5). A raiz quadrada é Math.Sqrt. Mais em Matemática (Math).

+ com texto junta, não soma

Se um dos lados do + é uma string, ele vira o operador de juntar textos (concatenar):

Console.WriteLine("1" + 2);
Console.WriteLine(1 + 2 + "3");
Console.WriteLine("1" + 2 + 3);
Console.WriteLine("1" + (2 + 3));
Console.WriteLine("Total: " + 10 + 5);

$ dotnet run concat.cs
12
33
123
15
Total: 105         « a Ana queria "Total: 15"

"1" + 2 → 12

Texto + número: o número vira texto e os dois se juntam.

1 + 2 + "3" → 33

Da esquerda para a direita: primeiro 1 + 2 = 3 (dois números, soma), depois 3 + "3" = "33".

"1" + 2 + 3 → 123

Primeiro "1" + 2 = "12" (texto), depois "12" + 3 = "123".

"1" + (2 + 3) → 15

Os parênteses fazem a soma antes: "1" + 5.

"Total: " + 10 + 5 → Total: 105

O erro de verdade: os números foram grudados no texto um de cada vez. Conserto: "Total: " + (10 + 5), ou a interpolação $"Total: {10 + 5}", que faz a conta dentro das chaves (aula Interpolação).

Os outros operadores não funcionam com texto. "10" - "3" não compila (veja "Quando dá errado"). Para fazer contas com números que estão num texto, converta primeiro: aula Texto → Número.

Quando dá errado

string a = "10";
string b = "3";
Console.WriteLine(a - b);

$ dotnet run subtrairstring.cs
/home/ana/cs/subtrairstring.cs(3,19): error CS0019: O operador "-" não pode ser aplicado a operandos dos tipos "string" e "string"

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

Referência rápida

Exercícios

Missão final: o filme em horas

int duracao = 142;
int horas = 0;
int minutos = 0;
Console.WriteLine($"O filme tem {horas} h {minutos} min");

int duracao = 142;
int horas = duracao / 60;
int minutos = duracao % 60;
Console.WriteLine($"O filme tem {horas} h {minutos} min");

Depois de cumprir a missão, troque 142 por 59 e por 600 e veja as horas e os minutos mudarem sozinhos.

Resumo

• Os operadores aritméticos: +, -, *, / e % (resto).
• Entre dois inteiros, / corta a parte decimal: 7 / 2 = 3, 1 / 3 = 0. Basta um lado com vírgula para a divisão ser normal: 7 / 2.0 = 3,5.
• % dá o resto: horas e minutos (/ 60 e % 60), par ou ímpar (% 2). O sinal do resto é o do número da esquerda.
• Divisão por zero: DivideByZeroException com inteiros e decimal; ∞, -∞ ou NaN com double; CS0020 se o zero está escrito no código.
• *, / e % antes de + e -; parênteses primeiro; no mesmo grupo, da esquerda para a direita.
• ^ não é potência (use Math.Pow), e + com texto junta ("Total: " + 10 + 5 = Total: 105).