Operadores e Expressões: Fazendo Contas e Combinando Valores

Você já sabe guardar valores em variáveis e conhece suas naturezas. Agora vamos fazê-los interagir — somar números, calcular totais, combinar textos, produzir novos valores a partir dos existentes. As ferramentas para isso são os operadores, símbolos como +, -, * e / que operam sobre valores, e as expressões, que são combinações de valores e operadores que o computador avalia para produzir um resultado. Esta é a aula em que seus programas ganham a capacidade de calcular, e com ela um mundo enorme de possibilidades se abre. Como sempre, construiremos cada ideia do chão, sem pressupor conhecimento prévio de matemática além do elementar.

O que é uma expressão

Comecemos pelo conceito central. Uma expressão é qualquer combinação de valores, variáveis e operadores que o computador consegue avaliar para chegar a um único valor. Por exemplo, 2 + 3 é uma expressão que o computador avalia, produzindo o valor 5. A variável idade sozinha também é uma expressão (avalia para o valor guardado). E preco * quantidade é uma expressão que multiplica dois valores. "Avaliar" uma expressão significa calcular o seu resultado — e esse resultado pode então ser guardado numa variável, exibido, ou usado em outra expressão maior.

Essa ideia de avaliação é fundamental. Quando você escreve int total = 2 + 3;, acontece em duas etapas: primeiro o C# avalia a expressão do lado direito (2 + 3 vira 5), e depois guarda esse resultado na variável total. É a mesma regra da atribuição que vimos na Aula #04, agora com uma expressão mais interessante do lado direito. Primeiro se calcula a direita; depois se guarda na esquerda.

Os operadores aritméticos

Para números (int, double, decimal), os operadores aritméticos fazem as contas que você conhece da matemática:

int soma = 10 + 3;         // adição:        13
int diferenca = 10 - 3;    // subtração:      7
int produto = 10 * 3;      // multiplicação:  30 (o * é o sinal de vezes)
int quociente = 10 / 3;    // divisão:        3  (atenção: veja abaixo!)
int resto = 10 % 3;        // resto:          1

Três desses merecem atenção. O * é a multiplicação — usamos o asterisco, não o "x". O / é a divisão, mas com uma surpresa importante que já aparece acima: 10 / 3 resultou em 3, e não em 3.333.... Isso acontece porque, quando ambos os valores são inteiros (int), o C# faz uma divisão inteira: ele descarta a parte fracionária e devolve apenas a parte inteira do resultado. Se você quer o resultado com casas decimais, ao menos um dos valores precisa ser de um tipo decimal:

double resultado = 10.0 / 3;   // 3.3333... — o 10.0 é double, então a divisão é decimal

O quinto operador, %, chama-se módulo e devolve o resto de uma divisão inteira: 10 % 3 é 1, porque 10 dividido por 3 dá 3 e sobra 1. O resto pode parecer curioso agora, mas é surpreendentemente útil — por exemplo, um número é par exatamente quando o resto de sua divisão por 2 é zero, um truque que usaremos adiante.

A ordem das operações

Quando uma expressão combina vários operadores, o C# segue a ordem de precedência da matemática: multiplicação e divisão (e módulo) acontecem antes de adição e subtração. Assim, 2 + 3 * 4 é avaliado como 2 + 12, resultando em 14, e não 20. Como na matemática, você pode usar parênteses para forçar a ordem que desejar:

int a = 2 + 3 * 4;      // 14 — a multiplicação vem primeiro
int b = (2 + 3) * 4;    // 20 — os parênteses forçam a soma primeiro

Os parênteses são seus aliados não apenas para mudar a ordem, mas também para deixar suas intenções claras. Mesmo quando a precedência natural já produziria o resultado certo, adicionar parênteses pode tornar uma expressão complexa mais fácil de ler. Clareza nunca é desperdício.

Combinando com variáveis: o poder real

O verdadeiro valor dos operadores aparece quando trabalhamos com variáveis, calculando resultados a partir de dados guardados:

int precoUnitario = 25;
int quantidade = 4;
int total = precoUnitario * quantidade;   // avalia 25 * 4, guarda 100 em 'total'
Console.WriteLine(total);                  // exibe: 100

Aqui, a expressão precoUnitario * quantidade primeiro lê os valores guardados nas duas variáveis (25 e 4), depois os multiplica, e o resultado (100) é guardado em total. Se as variáveis tivessem outros valores, o resultado se ajustaria — e é isso que torna o programa flexível: a mesma instrução calcula corretamente para quaisquer valores que as variáveis contenham. Você escreveu a fórmula; ela funciona para todos os casos.

Atalhos de atribuição

Uma operação tão comum que ganhou atalhos é modificar uma variável com base no seu próprio valor. Na Aula #04, vimos contador = contador + 1. O C# oferece uma forma abreviada, o operador +=:

int contador = 0;
contador += 1;   // equivale a: contador = contador + 1  → contador vira 1
contador += 5;   // equivale a: contador = contador + 5  → contador vira 6

Existem atalhos análogos para as outras operações: -= (subtrai), *= (multiplica), /= (divide). E, para o caso especialíssimo de somar ou subtrair um, há um atalho ainda mais curto: ++ (incrementa em 1) e -- (decrementa em 1):

int vidas = 3;
vidas--;   // equivale a vidas = vidas - 1  → vidas vira 2
vidas++;   // equivale a vidas = vidas + 1  → vidas vira 3

Esses atalhos não fazem nada de novo — apenas expressam de forma mais curta operações muito frequentes. O ++, em particular, aparecerá constantemente quando estudarmos laços de repetição, pois contar de um em um é uma das tarefas mais comuns em programação.

Um operador especial para texto: a concatenação

Os operadores não servem só a números. O +, quando aplicado a strings, faz algo diferente e útil: ele junta os textos, um após o outro — operação chamada concatenação:

string nome = "Ana";
string saudacao = "Olá, " + nome + "!";   // junta os três pedaços
Console.WriteLine(saudacao);               // exibe: Olá, Ana!

O mesmo símbolo +, portanto, tem comportamentos diferentes conforme os tipos envolvidos: soma números, mas concatena textos. Note o espaço dentro de "Olá, " — sem ele, sairia "Olá,Ana", grudado; os espaços dentro das aspas fazem parte do texto e você precisa colocá-los onde os quer. Existe uma forma ainda mais elegante de montar textos com valores embutidos, que estudaremos na aula dedicada à string; por ora, a concatenação com + já lhe permite compor mensagens dinâmicas, combinando texto fixo com o conteúdo de variáveis.

Os valores guardados agora podem ser combinados. Você domina os operadores aritméticos, incluindo o resto da divisão, conhece a ordem em que as operações são avaliadas e sabe forçar outra ordem com parênteses. Aprendeu também os atalhos de atribuição, que encurtam a forma longa sem mudar o significado, e viu o sinal de mais assumir um segundo papel ao juntar textos.

Uma armadilha clássica ficou antecipada: a divisão entre dois inteiros descarta a parte fracionária, e dez dividido por três resulta em três, não em três vírgula três. Não é um defeito da linguagem — é a consequência coerente de operar sobre inteiros, e reconhecê-la de imediato poupa horas de perplexidade.

Fontes e leituras recomendadas

• Operadores aritméticos em C# — a referência oficial de +, -, *, /, % e seus comportamentos; a base desta aula.
• Expressões (guia da linguagem) — o panorama dos operadores e da avaliação de expressões em C#.
• Precedência de operadores — a ordem em que os operadores são avaliados e o papel dos parênteses.
• Operadores de atribuição compostos — os atalhos +=, -=, ++, -- explicados.
• Concatenação de strings — como juntar textos, incluindo alternativas à concatenação com +.

Exercícios

Exercício 1

Escreva um programa que declare duas variáveis inteiras, a e b, com valores à sua escolha, e exiba o resultado das cinco operações aritméticas entre elas: soma, subtração, multiplicação, divisão e resto. Antes de rodar, preveja cada resultado.

int a = 20, b = 6;
Console.WriteLine(a + b);   // 26
Console.WriteLine(a - b);   // 14
Console.WriteLine(a * b);   // 120
Console.WriteLine(a / b);   // 3 (divisão inteira: 20/6 = 3, descartando a fração)
Console.WriteLine(a % b);   // 2 (resto de 20 dividido por 6)

Exercício 2

Explique, com suas palavras, por que 10 / 3 resulta em 3 e não em 3.333... em C#. Depois, mostre uma forma de obter o resultado com casas decimais e explique por que ela funciona.

Exercício 3

Avalie mentalmente as expressões a seguir, aplicando a ordem das operações, e depois confirme rodando: 2 + 3 * 4, (2 + 3) * 4, 10 - 2 - 3, 20 / 2 * 5. Para a última, reflita sobre por que o resultado é 50 e não 2.

Exercício 4

Escreva um programa que calcule e exiba o total de uma compra: declare precoUnitario (um decimal) e quantidade (um int), e calcule o total. Depois, use a concatenação para exibir uma frase como "O total é R$ ..." combinando texto com o valor calculado.

decimal precoUnitario = 12.50m;
int quantidade = 3;
decimal total = precoUnitario * quantidade;   // 37.50
Console.WriteLine("O total é R$ " + total);    // O total é R$ 37,50

Exercício 5

Usando o operador de resto (%), explique como você determinaria se um número guardado numa variável é par ou ímpar. (Você não precisa escrever a decisão completa ainda — apenas explique qual expressão usaria e o que o resultado dela indicaria.)