Booleanos e Comparações: Como o Programa Formula Perguntas

Até este ponto, todos os nossos programas compartilham uma limitação silenciosa: eles executam sempre a mesma sequência de instruções, de cima para baixo, independentemente dos dados. Um programa assim é como um trem sobre trilhos únicos — vai sempre pelo mesmo caminho. Mas os programas úteis precisam decidir: mostrar uma mensagem se o usuário for maior de idade, cobrar frete se a compra for barata, avisar se a senha for curta demais. Toda decisão começa com uma pergunta que só admite duas respostas: sim ou não, verdadeiro ou falso. Esta aula ensina como o programa formula essas perguntas. Ainda não tomaremos decisões com base nas respostas — isso é a próxima aula —, mas construiremos o alicerce sem o qual nenhuma decisão é possível: os valores booleanos e os operadores de comparação.

Revisitando o bool: o tipo de duas faces

Na Aula #05, conhecemos de passagem o tipo bool, que guarda apenas um de dois valores: true (verdadeiro) ou false (falso). Naquele momento, ele parecia modesto ao lado dos números e do texto. Agora ele assume seu papel central: o bool é a resposta de toda pergunta que o programa faz a si mesmo. Cada decisão que um programa toma se apoia, no fundo, num valor booleano — um verdadeiro ou falso que determina qual caminho seguir. Podemos guardar esses valores em variáveis, como qualquer outro:

bool estaChovendo = true;
bool provaFoiAprovada = false;
Console.WriteLine(estaChovendo);   // exibe: True

Mas guardar true ou false escritos diretamente por nós é pouco interessante. O poder do bool aparece quando ele é calculado a partir de outros dados — quando o programa formula uma pergunta sobre seus valores e obtém, como resposta, um verdadeiro ou falso. É isso que os operadores de comparação fazem.

Os operadores de comparação

Um operador de comparação pega dois valores, faz uma pergunta sobre a relação entre eles, e produz um bool como resposta. São seis, e correspondem a perguntas que você conhece da matemática:

int a = 5;
int b = 8;

Console.WriteLine(a == b);   // a é IGUAL a b?           False
Console.WriteLine(a != b);   // a é DIFERENTE de b?      True
Console.WriteLine(a < b);    // a é MENOR que b?         True
Console.WriteLine(a > b);    // a é MAIOR que b?         False
Console.WriteLine(a <= b);   // a é menor OU IGUAL a b?  True
Console.WriteLine(a >= b);   // a é maior OU IGUAL a b?  False

Cada linha é uma pergunta cuja resposta é um bool. Repare que a < b não é um comando para tornar a menor que b; é uma pergunta — "a é menor que b?" — que o computador avalia como verdadeira ou falsa, exatamente como avalia 2 + 3 como 5. Uma comparação é uma expressão, como qualquer outra, só que produz um bool em vez de um número.

Dois desses operadores merecem atenção especial. O primeiro é o ==, de igualdade, com dois sinais de igual. Aqui mora uma das confusões mais comuns de quem começa: = (um sinal) é atribuição — "guarde este valor" (Aula #04) —, enquanto == (dois sinais) é comparação de igualdade — "estes dois valores são iguais?". São coisas completamente diferentes: idade = 30 guarda 30 em idade; idade == 30 pergunta se idade vale 30, respondendo verdadeiro ou falso. Confundir os dois é um erro clássico, e felizmente o C# costuma avisá-lo quando você usa um no lugar do outro. Grave a distinção: um igual guarda; dois iguais comparam. O segundo operador de nota é o !=, que significa "diferente de" — o ponto de exclamação, em programação, carrega frequentemente a ideia de negação, de "não".

Comparações não se restringem a números. Textos também podem ser comparados por igualdade, o que é muito útil para verificar respostas:

string resposta = "sim";
Console.WriteLine(resposta == "sim");   // True — os textos são iguais
Console.WriteLine(resposta == "não");   // False

Combinando perguntas: os operadores lógicos

Muitas decisões dependem de mais de uma condição ao mesmo tempo. "O usuário pode entrar se for maior de idade e tiver ingresso." "Aplica-se desconto se o cliente for novo ou a compra for grande." Para combinar perguntas, existem os operadores lógicos, que operam sobre valores booleanos e produzem um novo booleano.

O operador && significa "e": o resultado é verdadeiro apenas se ambas as condições forem verdadeiras.

int idade = 20;
bool temIngresso = true;

bool podeEntrar = (idade >= 18) && temIngresso;   // verdadeiro E verdadeiro → True
Console.WriteLine(podeEntrar);                      // True

Aqui, podeEntrar só é verdadeiro porque as duas condições são: a idade é 18 ou mais, e há ingresso. Se qualquer uma falhasse, o resultado seria falso. O && é exigente: pede que tudo seja verdadeiro.

O operador || significa "ou": o resultado é verdadeiro se pelo menos uma das condições for verdadeira.

bool clienteNovo = false;
decimal valorCompra = 500m;

bool temDesconto = clienteNovo || (valorCompra > 300);   // falso OU verdadeiro → True
Console.WriteLine(temDesconto);                            // True

Aqui, temDesconto é verdadeiro mesmo o cliente não sendo novo, porque a outra condição (compra acima de 300) é verdadeira, e o || se contenta com uma. O || é generoso: basta uma verdadeira. (Os dois símbolos, && e ||, exigem os caracteres duplicados; o caractere | sozinho, chamado "barra vertical", fica geralmente numa tecla acessada com Shift, acima da barra invertida no teclado.)

Por fim, o operador !, chamado "não" (ou negação), inverte um valor booleano: transforma verdadeiro em falso e falso em verdadeiro.

bool estaChovendo = true;
bool estaSeco = !estaChovendo;   // inverte: NÃO chovendo → False
Console.WriteLine(estaSeco);     // False

O ! é útil para expressar o oposto de uma condição de forma direta — "não está chovendo", "não está vazio", "não foi aprovado".

Perguntas são apenas expressões

Vale reforçar a ideia que unifica tudo nesta aula: uma comparação ou combinação lógica é apenas uma expressão que resulta num bool, exatamente como 2 + 3 é uma expressão que resulta num número. Você pode guardá-la numa variável (bool aprovado = nota >= 7;), exibi-la, ou — o que faremos na próxima aula — usá-la para decidir. Nada de novo em espírito: estamos calculando valores, só que valores de verdadeiro/falso, com operadores próprios. Essa continuidade é importante: você não está aprendendo um mecanismo estranho, e sim aplicando a ideia de expressão, que já domina, a um novo tipo de resultado.

O programa ganhou a capacidade de formular perguntas. O tipo bool, que antes parecia o mais modesto da lista de tipos primitivos, revelou-se a peça sobre a qual toda decisão se apoia: os operadores de comparação produzem valores booleanos, e os operadores lógicos os combinam em perguntas compostas.

O ponto conceitual que vale reter é que uma comparação não é uma construção especial da linguagem — é apenas uma expressão, como uma soma, só que resultando em verdadeiro ou falso. Ela pode ser guardada numa variável, nomeada e reaproveitada, e isso costuma deixar o código muito mais legível do que repetir a condição inteira.

Fontes e leituras recomendadas

• O tipo bool — a referência oficial do tipo verdadeiro/falso; a base desta aula.
• Operadores de comparação — a referência de <, >, <=, >= e seu comportamento.
• Operadores de igualdade — sobre == e !=, com a importante distinção em relação ao =.
• Operadores lógicos booleanos — a referência de &&, || e ! para combinar condições.
• Expressões booleanas (conceito) — o panorama de como as expressões que resultam em verdadeiro/falso se encaixam na linguagem.

Exercícios

Exercício 1

Declare duas variáveis inteiras com valores à sua escolha e exiba o resultado das seis comparações (==, !=, <, >, <=, >=) entre elas. Antes de rodar, preveja cada resultado (verdadeiro ou falso).

int a = 7, b = 4;
Console.WriteLine(a == b);   // False
Console.WriteLine(a != b);   // True
Console.WriteLine(a < b);    // False
Console.WriteLine(a > b);    // True
Console.WriteLine(a <= b);   // False
Console.WriteLine(a >= b);   // True

Exercício 2

Explique, com suas palavras e um exemplo de cada, a diferença entre =, ==. Por que confundir os dois é um erro comum, e o que cada um realmente faz?

Exercício 3

Crie três variáveis: idade (um número), temCarteira (um bool) e estaSobrio (um bool). Escreva uma expressão que combine as três com && para determinar se uma pessoa podeDirigir (maior de idade, com carteira, e sóbria), e exiba o resultado. Depois, mude um dos valores e observe como o resultado muda.

int idade = 25;
bool temCarteira = true;
bool estaSobrio = true;
bool podeDirigir = (idade >= 18) && temCarteira && estaSobrio;
Console.WriteLine(podeDirigir);   // True

Exercício 4

Usando ||, escreva uma expressão que determine se um dia é "de descanso": verdadeiro se for sábado ou se for feriado. Use dois bool (ehSabado, ehFeriado) e explique por que o || é o operador apropriado aqui, e não o &&.

bool ehSabado = true;
bool ehFeriado = false;
bool diaDeDescanso = ehSabado || ehFeriado;
Console.WriteLine(diaDeDescanso);   // True

Exercício 5

Sem código: explique a diferença entre os operadores && e || em termos de exigência — em que situação cada um produz verdadeiro. Depois, explique o que o operador ! faz, dando um exemplo de uma condição e sua negação.