Comando switch case: estrutura de seleção

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:

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.