Siga-nos

Inscreva-se

Siga-nos

Inscreva-se

Comando switch case: estrutura de seleção

Aprenda todos os detalhes do comando switch case. O comando que te permite criar estruturas de seleção em programação de computadores.

O comando switch case é um excelente recurso das linguagens de programação para criar estruturas de seleção. Funciona como um substituto para longas estruturas condicionais que utilizam expressões if-else.

Se você ainda não sabe o que são estruturas condicionais, leia o nosso artigo que explica detalhadamente sobre esse assunto.

Bem! Mas vamos ao que interessa!

A estrutura do comando switch case

O comando switch case é uma ferramenta para construir estruturas condicionais de forma mais elegante.

Basicamente, ele fornece um mecanismo para substituir as estruturas que usam if-else aninhados por uma estrutura mais limpa e objetiva.

O código abaixo ilustra a estrutura básica do comando switch case:

1.switch(variável){

2.case valor1:

3.     //comandos executados se "variável" == valor1 

4.     break;

5.case valor2:

6.     //comandos executados se "variável" == valor2  

7.     break;

8....

9.default:

10.     //comandos executados se "variável" for diferente de todos  

11.}

Ele é composto por uma variável (linha 1 do código acima) cujo valor é testado pelas cláusulas case (linhas 2 e 5 do código acima). Caso o valor da variável seja igual a algum dos valores das cláusulas case, os respectivos comandos serão executados (linhas 3 e 6 do código acima).

A cláusula default (linha 9 do código acima) representa o caso de exceção. Se o valor da variável não for igual a nenhum valor testado pelas cláusulas case, os comandos da cláusula default são executados (linha 10 do código acima).

O comando break (linhas 4 e 7 do código acima) é necessário após os comandos de cada cláusula case. Ele serve para que a estrutura seja interrompida após a execução de algum dos comandos. Isso evita que outros testes sejam executados.

Entendendo o comando switch case

Para entender o funcionamento do switch case vamos imaginar um algoritmo para comparar o valor de uma variável numérica e imprimir níveis de dificuldade.

Utilizando if-else

O código abaixo ilustra a implementação desse algoritmo com o uso dos já conhecidos comandos if-else:

1.if(nivel==1){

2.     println("Fácil");

3.}else if(nivel==2){

4.     println("Moderado");

5.}else if(nivel==3){

6.     println("Difícil");

7.}else{

8.     println("Erro!");

9.}

Observe nas linhas 1, 3, 5, e 7 (código acima) que as expressões condicionais filtram os possíveis valores da varável “nivel” e imprimem uma mensagem específica para cada um desses valores.

O comando else (linha 7 do código acima) serve como um filtro de exceção. Caso nenhuma das alternativas anteriores foram verdadeiras, a linha 8 (código acima) é executada.

Utilizando switch case

Bom! Agora vamos reescrever esse mesmo algoritmo utilizando a estrutura de seleção switch case:

1.switch(nivel){

2.case 1:

3.     println("Fácil");

4.     break;

5.case 2:

6.     println("Moderado");

7.     break;

8.case 3:

9.     println("Difícil");

10.     break;

11.default:

12.     println("Erro!");

13.}

Percebeu a diferença? Observe como o código é mais limpo! Ao invés de usas a expressão “nível==1“, usamos apenas a palavra “case 1:“.

Observe nas linhas 2, 5, e 8 (código acima) como não precisamos usar o operador relacional de igualdade “==“. No comando switch case, o operador de igualdade já está implícito. Não precisamos escrevê-lo.

Contudo, é importante observar que nem todas as linguagens de programação dão suporte para esse comando. A linguagem Python, por exemplo, não possui o comando switch case, devendo-se usar no seu lugar a estrutura if-else.

Veja abaixo o código acima implementado em várias linguagens de programação diferentes:

  • Java
  • C
  • C++
  • C#
  • Python

1.import java.util.Scanner;

2.class Main {

3.     public static void main(String[] args) {

4.          Scanner scanner = new Scanner(System.in);

5.          System.out.println("Digite o nível, de 1 a 3:");

6.          int nivel=scanner.nextInt();

7.          switch(nivel){

8.          case 1:

9.               System.out.println("Fácil");

10.               break;

11.          case 2:

12.               System.out.println("Moderado");

13.               break;

14.          case 3:

15.               System.out.println("Difícil");

16.               break;

17.          default:

18.               System.out.println("Erro!");

19.          }

20.     }

21.}

1.#include <stdio.h>

2.int main(void) {

3.     printf("Digite o nível, de 1 a 3:\n");

4.     int nivel;

5.     scanf("%d",&nivel);

6.     switch(nivel){

7.     case 1:

8.          printf("Fácil");

9.          break;

10.     case 2:

11.          printf("Moderado");

12.          break;

13.     case 3:

14.          printf("Difícil");

15.          break;

16.     default:

17.          printf("Erro!");

18.     }

19.}

1.#include <iostream>

2.int main() {

3.     std::cout << "Digite o nível, de 1 a 3:\n";

4.     int nivel;

5.     std::cin >> nivel;

6.     switch(nivel){

7.     case 1:

8.          std::cout << "Fácil";

9.          break;

10.     case 2:

11.          std::cout <<"Moderado";

12.          break;

13.     case 3:

14.          std::cout <<"Difícil";

15.          break;

16.     default:

17.          std::cout <<"Erro!";

18.     }

19.}

1.using System;

2.class MainClass {

3.     public static void Main (string[] args) {

4.          Console.WriteLine("Digite o nível, de 1 a 3:");

5.          int nivel=Convert.ToInt32(Console.ReadLine());

6.          switch(nivel){

7.          case 1:

8.               Console.WriteLine("Fácil");

9.               break;

10.          case 2:

11.               Console.WriteLine("Moderado");

12.               break;

13.          case 3:

14.               Console.WriteLine("Difícil");

15.               break;

16.          default:

17.               Console.WriteLine("Erro!");

18.               break;

19.          }

20.     }

21.}

1.# Python não possui suporte para o comando switch/case 

2.# Deve-se utilizar estrutura if-else 

3.nivel = int(input("Digite o nível, de 1 a 3:\n"))

4.if nivel==1:

5.     print("Fácil")

6.elif nivel==2:

7.     print("Moderado")

8.elif nivel==3:

9.     print("Difícil")

10.else:

11.     print("Erro!")

Limitação do comando switch case

Vimos que uma estrutura de seleção switch case utiliza implicitamente o operador relacional==” para realizar as comparações. A consequência disso é que, se uma estrutura condicional (que usa if-else) usar outros operadores relacionais, ela não poderá ser transformada em um switch case!

Para entender isso melhor, observe o algoritmo que classifica um aluno em categorias, de acordo com a sua idade.

1.if(idade < 12){

2.     println("Categoria: INFANTIL");

3.} else if(idade < 16){

4.     println("Categoria: JUVENIL");

5.} else if(idade < 20){

6.     println("Categoria: JUNIOR");

7.} else {

8.     println("Categoria: ADULTO");

9.}

Podemos ver nas linhas 1, 3 e 5 (código acima) que é utilizado o operador menor que<” para realizar as comparações dentro das expressões condicionais.

Isso significa que a estrutura acima não pode ser transformada em uma estrutura de seleção!

Ou seja, se uma estrutura for composta por expressões condicionais que usam operadores relacionais diferentes de “==“, tais como “>“, “<“, “>=“, “<=” e “!=“, elas não podem ser convertidas para estruturas de seleção switch case!

Dê o próximo passo. Leia o nosso artigo sobre arrays. Adentre no maravilhoso universo das coleções de dados da programação.

Este artigo foi útil para você?

Então nos ajude a crescer e compartilhe-o com outras pessoas que se interessam por esse assunto!

Share on whatsapp
WhatsApp
Share on facebook
Facebook
Share on twitter
Twitter
Share on linkedin
LinkedIn
Share on email
Email

Siga-nos

Inscreva-se

O primeiro livro didático de programação para jogos digitais

Este site usa cookies para garantir que você obtenha a melhor experiência.