Switch case em C++: aprenda em 7 minutos!

Assim como o if else, o switch case em C++ permite ao usuário executar certas ações baseando-se no valor de uma expressão.

O switch case é normalmente utilizado quando se deseja uma sintaxe alternativa ao if, para testar valores específicos de uma expressão, ao invés de realizar algum teste mais abrangente nessa mesma expressão; ou seja, para fazer algo do tipo x == 10 ao invés de x <= 10. Neste sentido, o switch case em C++ é mais específico que o if else.

Vejamos a seguir um exemplo simples do uso do switch case.

---

Exemplo 1 – Uso simples do switch case em C++

#include <iostream>

using namespace std;

int main()
{
    const int nota {5};
    
    switch (nota) {
        case 10:
            cout << "Excelente!" << endl;
            break;
        case 9:
            cout << "Ótimo!" << endl;
            break;
        case 8:
            cout << "Muito bom!" << endl;
            break;
        case 7:
            cout << "Bom!" << endl;
        default:
            cout << "Boa sorte na próxima." << endl;
            break;
    }

    return 0;
}

---

Vemos no exemplo 1 algumas características importantes do switch case em C++, as quais valem a pena ser discutidas com mais detalhes.

---

Expressão e cases do switch case

A primeira coisa a se notar é que a expressão do switch deve ter um valor inteiro, convertível para inteiro, ou um enumerador (com ou sem escopo). No exemplo 1, utilizei o valor da variável nota, de tipo inteiro, como expressão do switch.

Em seguida, é preciso saber que as mesmas restrições de tipos que se aplicam à expressão do switch se aplicam também às instruções case; todavia, o case tem uma restrição adicional: seus valores devem ser expressões constantes. Assim sendo, eu não poderia escrever case x:, sendo x uma variável não constante.

Uma vez que o case que contém o valor correspondente à expressão do switch é encontrado, o código que vem após os dois-pointos (:) é executado até que se alcance uma instrução break.

break

A instrução break nos switch case em C++ (e também nos laços de repetição) permitem encerrar a execução de toda a estrutura, devolvendo o controle do código para a função que executou o switch case.

Se o break for omitido, quando o bom case for encontrado, o código que se segue será executado, e a execução continuará através dos outros cases, executando os seus códigos também, como em uma queda livre através de todo o switch case, até que se encontre um break. Esse fenônemo é chamado de fallthrough.

default

Se nenhum dos case tiver um valor igual ao da expressão do switch, a execução será transferida para o bloco de código após a instrução default, se ela existir; se não existir, o switch se encerrará sem executar nenhum código. No exemplo 1, como o valor de nota é 5, não há nenhum case que corresponda a esse valor, fazendo com que a execução caia no default,e por isso vemos na saída o texto “Boa sorte na próxima.”

---

Sintaxe do switch case em C++

---

Switch case em C++ usando enums

No início do artigo eu falei que o valor da expressão do switch poderia ser um enumerador (posto que os elementos de enums são convertíveis para inteiros, e essa uma restrição das expressões do switch). Bem, a seguir mostrarei um exemplo utilizando um enumerador (ou seja, um elemento de um enum) na expressão do switch e também nas contantes dos case.

---

Exemplo 2- switch case usando scoped enums

#include <iostream>

using namespace std;

enum class Nivel {
    Junior = 0,
    Pleno,
    Senior
};

int main()
{
    switch (Nivel dev{Nivel::Pleno}; dev) {
        using enum Nivel;

        case Junior:
            cout << "Bem-vindo ao time!" << endl;
            break;
        case Pleno:
            [[fallthrough]];
        case Senior:
            cout << "Obrigado por ajudar os novatos!" << endl;
            break;
        default:
            cout << "Quem é você?" << endl;
            break;
    }
    
    return 0;
}

---

Inicializador do switch

No exemplo 2, comecei por definir um enum com escopo chamado Nivel que possui 3 valores: Junior, Pleno e Senior, que indicam o nível de experiência de um programador. Em seguida, na linha 13, eu utilizei o campo de inicialização do switch para criar uma variável dev que contém o valor Pleno (note o uso do Nivel:: antes do valor, necessário nos enums com escopo). Em seguida, utilizei a variável dev como expressão de teste do switch.

Na linha seguinte, vemos a expressão using enum Nivel, que serve para introduzir o escopo do enum no escopo local, o que significa simplesmente que podemos agora usar os valores do enum sem precedê-los de Nivel::. Isso é válido apenas dentro do switch case, onde a expressão using enum Nivel foi escrita.

Fallthrough – C++17

Vemos na linha 20 do exemplo 2 o atributo [[fallthrough]], que serve para indicar ao compilador que desejamos realizar uma queda proposital através dos case. Neste caso, eu queria que para ambos os níveis Pleno e Senior a mensagem impressa na saída fosse “Obrigado por ajudar os novatos!“, e podemos ver que isso é o que acontece no exemplo. Se quiser saber mais sobre o atributo, visite o artigo do CppReference sobre o assunto (é uma pena que ele esteja disponível apenas em inglês).

Próximos passos

Agora que conhecemos o switch case em C++, juntamente com o artigo sobre if else cobrimos as principais estruturas de controle condicional da linguagem, e estamos prontos para passar à próxima etapa no nosso aprendizado: os laços de repetição for. Vejo vocês lá!

Como usar for em C++: estrutura explicada em 3 pontos, sem mistério! »

Gostou do artigo? Então inscreva-se na nossa newsletter para não perder nenhum dos nossos artigos 🙂