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.
Sempre lembre-se de utilizar break; ao fim do corpo dos case (a menos que você deseje que aconteça um fallthrough), para evitar que o código de outros case sejam executados por acidente.
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++
Sintaxe – switch case
switch (<inicializador>; <expressão do switch>) {
case <condição 1>:
{corpo da cond. 1};
break;
…
case <condição n>:
{corpo da cond. n};
break;
default:
{corpo do default};
break;
}
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.
As variáveis criadas no campo de inicialização do switch são válidas apenas dentro do escopo do switch case. Fora do switch case elas são invisíveis ao compilador.
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 🙂
Sou apaixonado por tecnologia, literatura e também filosofia. O cultivo dessas paixões ao longo da minha trajetória me inspiraram a compartilhar aquilo que aprendo com os outros da maneira mais clara que eu possa. Sou formado em Engenharia Elétrica no Brasil, e também sou engenheiro formado na França. Trabalho atualmente como programador C++ em uma multinacional francesa, uma das maiores empresas de TI do mundo.
