Operadores e Estruturas de Decisão em C++

Nas duas semanas passadas, você aprendeu a estrutura de um programa em C++ e como guardar valores em variáveis. Mas repare numa coisa: todo valor usado até agora era fixo, escrito direto no código, ou vinha pronto do teclado através do cin. Nenhum programa fazia uma conta de verdade, nem escolhia um caminho diferente dependendo do que acontecia. Esta semana muda isso: você vai aprender a calcular novos valores com os operadores aritméticos, a comparar e combinar valores com os operadores relacionais e lógicos, e a fazer o programa tomar decisões, com a estrutura if/else. É aqui que um programa deixa de ser uma sequência fixa de comandos e passa a reagir a diferentes situações, do mesmo jeito que o SE do pseudocódigo, lá na Semana 1, já fazia no papel.

Base bibliográfica: este material segue as seções 3.3.7 (Operadores e funções predefinidas em C/C++) e 4.3 (Estrutura condicional em C/C++) de ASCENCIO & CAMPOS, Fundamentos da Programação de Computadores (3. ed., Pearson, 2012).

1. Operadores aritméticos

C++ oferece cinco operadores para calcular com valores numéricos:

Divisão inteira e divisão real

Quando os dois operandos de uma divisão são do tipo int, o resultado também é int: a parte decimal é descartada, não arredondada.

int a = 7, b = 2;
cout << a / b;   // resultado: 3

Para obter um resultado com casas decimais, pelo menos um dos operandos precisa ser double:

double x = 7.0, y = 2.0;
cout << x / y;   // resultado: 3.5

O tipo do resultado de uma divisão depende do tipo dos operandos envolvidos na conta, não do tipo da variável que vai receber o valor. Mesmo guardando o resultado de 7 / 2 numa variável double, o valor perdido não volta: a conta acontece primeiro, com os tipos originais.

O operador de módulo

O operador % obtém o resto de uma divisão entre dois números inteiros, e só funciona com operandos do tipo int.

cout << 7 % 2;    // resultado: 1
cout << 10 % 5;   // resultado: 0

Uma aplicação comum do módulo é verificar se um número é par ou ímpar: o resto da divisão por 2 é 0 para números pares, e 1 para números ímpares.

Precedência e parênteses

Quando uma expressão combina mais de um operador, C++ segue uma ordem de precedência: *, / e % são avaliados antes de + e -.

int resultado = 2 + 3 * 4;   // 3 * 4 primeiro: resultado = 14

Parênteses forçam uma parte da expressão a ser avaliada primeiro, independentemente da precedência padrão:

int r1 = 2 + 3 * 4;     // 14
int r2 = (2 + 3) * 4;   // 20

Atalhos: atribuição composta e incremento/decremento

C++ oferece formas abreviadas de atualizar o valor de uma variável a partir dela mesma:

int x = 10;
x += 5;   // equivalente a x = x + 5;
x -= 3;   // equivalente a x = x - 3;
x *= 2;   // equivalente a x = x * 2;
x /= 4;   // equivalente a x = x / 4;

Os operadores ++ e -- somam ou subtraem 1 do valor de uma variável:

int contador = 0;
contador++;   // equivalente a contador = contador + 1;
contador--;   // equivalente a contador = contador - 1;

Esses dois atalhos vão aparecer com frequência mais adiante no curso, na construção de contadores dentro de laços de repetição.

🎥 Vídeo 1 de 3: Operadores aritméticos e precedência (~6 min)

2. Operadores relacionais e lógicos

Operadores relacionais comparam dois valores e produzem um resultado do tipo bool:

bool maior = (5 > 3);
cout << maior;    // resultado: 1

bool igual = (5 == 3);
cout << igual;    // resultado: 0

Ao exibir um valor do tipo bool com cout, C++ mostra 1 para true (verdadeiro) e 0 para false (falso).

Atribuição e comparação: dois operadores diferentes

O sinal =, com um único caractere, atribui um valor a uma variável. O sinal ==, com dois caracteres, compara dois valores. Trocar um pelo outro é um dos erros mais frequentes entre quem está aprendendo C++, porque o código costuma compilar normalmente e produzir um resultado incorreto.

int idade = 18;
idade = 20;    // atribuição: idade passa a valer 20
idade == 20;   // comparação: verifica se idade vale 20

Operadores lógicos

Operadores lógicos combinam duas ou mais condições relacionais, ou invertem o resultado de uma condição:

Tabela-verdade do &&:

Tabela-verdade do ||:

int idade = 20;
bool possui_carteira = true;

bool pode_dirigir = (idade >= 18) && possui_carteira;
cout << pode_dirigir;   // resultado: 1

Cada condição entre parênteses é avaliada de forma independente, antes de o operador lógico combinar os resultados.

Precedência geral

Juntando os operadores aritméticos, relacionais e lógicos, esta é a ordem de avaliação, da maior para a menor prioridade:

1. Parênteses
2. Negação !
3. * / %
4. + -
5. Relacionais: == != > < >= <=
6. &&
7. ||

Na dúvida sobre a ordem, parênteses sempre deixam a expressão mais fácil de ler.

🎥 Vídeo 2 de 3: Operadores relacionais e lógicos (~6 min)

3. Estrutura de decisão

Até este ponto, todo programa executava suas instruções sempre na mesma ordem, de cima para baixo. Uma estrutura de decisão permite que o programa escolha um caminho diferente, dependendo do resultado de uma condição, a mesma condição construída com os operadores relacionais e lógicos da seção anterior.

A instrução if

A instrução if executa um bloco de comandos somente quando a condição, escrita entre parênteses, é verdadeira.

if (idade >= 18) {
    cout << "Maior de idade" << endl;
}

Se a condição for falsa, o bloco é ignorado, e a execução do programa continua na linha seguinte.

Em C++, o uso de chaves { } é obrigatório sempre que houver mais de um comando dentro do if. Manter as chaves mesmo com um único comando é uma boa prática: evita erros quando uma nova linha é adicionada depois.

A instrução if/else

A cláusula else define um segundo bloco de comandos, executado quando a condição do if é falsa. Exatamente um dos dois blocos é executado: nunca os dois, e nunca nenhum.

if (idade >= 18) {
    cout << "Maior de idade" << endl;
} else {
    cout << "Menor de idade" << endl;
}

Um programa completo, lendo a idade digitada e classificando a maioridade:

#include <iostream>
using namespace std;

int main() {
    int idade;
    cout << "Digite a idade: ";
    cin >> idade;

    if (idade >= 18) {
        cout << "Maior de idade" << endl;
    } else {
        cout << "Menor de idade" << endl;
    }
    return 0;
}

Em C++, a condição do if é obrigatoriamente escrita entre parênteses, mesmo quando é uma única comparação. Essa é uma diferença em relação ao pseudocódigo estudado na Semana 1, onde o SE não exigia esse formato.

Decisões aninhadas

Uma estrutura de decisão aninhada é um if (ou if/else) escrito dentro do bloco de outro if. Ela é usada quando uma segunda decisão só faz sentido depois que a primeira condição já foi avaliada como verdadeira.

if (idade >= 18) {
    if (possui_carteira) {
        cout << "Pode dirigir" << endl;
    } else {
        cout << "Precisa tirar a carteira" << endl;
    }
} else {
    cout << "Ainda não tem idade para dirigir" << endl;
}

A segunda decisão, sobre a carteira, só é avaliada quando a primeira condição, sobre a maioridade, já é verdadeira.

A cláusula else if

Quando existem várias condições mutuamente exclusivas para testar em sequência, else if encadeia as verificações de forma mais legível do que aninhar vários blocos.

if (nota >= 9.0) {
    cout << "Conceito A" << endl;
} else if (nota >= 7.0) {
    cout << "Conceito B" << endl;
} else if (nota >= 5.0) {
    cout << "Conceito C" << endl;
} else {
    cout << "Conceito D" << endl;
}

As condições de uma cadeia else if são avaliadas em ordem, de cima para baixo. Assim que uma condição verdadeira é encontrada, o bloco correspondente é executado, e as demais condições deixam de ser testadas: por isso, elas costumam ser escritas da mais restritiva para a mais abrangente.

O aninhamento é indicado quando a segunda decisão depende do resultado da primeira. O else if é indicado quando as condições testam a mesma variável em faixas de valores mutuamente exclusivas. Os dois recursos podem ser combinados num mesmo programa, conforme a necessidade de cada decisão.

🎥 Vídeo 3 de 3: Estrutura de decisão: if, if/else e aninhamento (~8 min)

Leitura da Semana 3 - Base: Ascencio & Campos, seções 3.3.7 e 4.3. Faça a lista de exercícios e traga suas dúvidas para o encontro síncrono.