switch…case em C (instrução Switch em C) com exemplos

⚡ Resumo Inteligente

A instrução switch em C compara uma expressão com vários rótulos de caso e executa o bloco correspondente, oferecendo uma alternativa mais limpa às longas cadeias if-else quando um programa precisa escolher entre muitos valores inteiros ou de caracteres fixos.

  • 🔀 Ramificação múltipla: Um switch testa uma expressão e salta para o rótulo do caso correspondente.
  • 🏷️ Etiquetas da caixa: Cada caso utiliza um rótulo único, seja um número inteiro constante ou um caractere, terminando com dois pontos.
  • ⛔ Palavra-chave de quebra: A instrução `break` encerra um caso; sem ela, a execução falha.
  • 🧩 Caso padrão: O bloco padrão opcional é executado quando nenhum rótulo de caso corresponde à expressão.
  • 📋 Regras do Switch: Os rótulos dos casos permanecem constantes e únicos, sendo permitido apenas um rótulo padrão.

Instrução Switch em C

O que é instrução Switch em C?

A instrução `switch` em C testa o valor de uma variável e o compara com vários casos. Assim que um caso correspondente é encontrado, um bloco de instruções associado a esse caso específico é executado.

Cada caso em um bloco de um switch possui um nome/número diferente, conhecido como identificador. O valor fornecido pelo usuário é comparado com todos os casos dentro do bloco switch até que a correspondência seja encontrada.

Se uma correspondência de caso NÃO for encontrada, a instrução padrão será executada e o controle sairá do bloco switch.

Sintaxe de caixa de mudança

Uma sintaxe geral de como o caso de comutação é implementado em um programa 'C' é a seguinte:

switch( expression )
{
	case value-1:
			Block-1;
			Break;
	case value-2:
			Block-2;
			Break;
	case value-n:
			Block-n;
			Break;
	default:
			Block-1;
			Break;
}
Statement-x;
  • A expressão pode ser uma expressão inteira ou uma expressão de caractere.
  • Os valores 1, 2, n são rótulos de caso usados ​​para identificar cada caso individualmente. Lembre-se de que os rótulos dos casos não devem ser iguais, pois isso pode criar um problema durante a execução de um programa. Suponha que temos dois casos com o mesmo rótulo '1'. Então, durante a execução do programa, o caso que aparece primeiro será executado mesmo que você queira que o programa execute um segundo caso. Isso cria problemas no programa e não fornece o resultado desejado.
  • Os rótulos dos casos sempre terminam com dois pontos ( : ). Cada um desses casos está associado a um bloco.
  • Um bloco nada mais é do que múltiplas instruções agrupadas para um caso específico.
  • Sempre que a chave é executada, o valor da expressão de teste é comparado com todos os casos que definimos dentro da chave. Suponha que a expressão de teste contenha o valor 4. Este valor é comparado com todos os casos até o caso cujo rótulo quatro é encontrado no programa. Assim que um caso é encontrado, o bloco de instruções associado a esse caso específico é executado e o controle sai do switch.
  • A palavra-chave break em cada caso indica o fim de um caso específico. Se não colocarmos o break em cada caso, mesmo que o caso específico seja executado, o switch em C continuará a executar todos os casos até que o final seja alcançado. Isso não deveria acontecer; portanto, sempre temos que colocar a palavra-chave break em cada caso. Break encerrará o caso assim que for executado e o controle cairá da chave.
  • O caso padrão é opcional. Sempre que o valor da expressão de teste não corresponder a nenhum dos casos dentro do switch, o padrão será executado. Caso contrário, não é necessário escrever o padrão no switch.
  • Assim que a opção for executada, o controle irá para a instrução x e a execução de um programa continuará.

Fluxograma de declaração de switch

O diagrama a seguir ilustra como um caso é selecionado no switch case:

Fluxograma de declaração de switch

Como funciona a mudança

Exemplo de troca de caso em C

O programa a seguir ilustra o uso do switch:

#include <stdio.h>
    int main() {
        int num = 8;
        switch (num) {
            case 7:
                printf("Value is 7");
                break;
            case 8:
                printf("Value is 8");
                break;
            case 9:
                printf("Value is 9");
                break;
            default:
                printf("Out of range");
                break;
        }
        return 0;
    }

Saída:

Value is 8

Exemplo de troca de caso em C

  1. No programa fornecido, inicializamos um variável num com valor 8.
  2. Uma construção switch é usada para comparar o valor armazenado na variável num e executar o bloco de instruções associado ao caso correspondente.
  3. Neste programa, como o valor armazenado na variável num é oito, um switch executará o caso cujo rótulo de caso é 8. Após executar o caso, o controle sairá do switch e o programa será encerrado com o resultado bem-sucedido por imprimindo o valor na tela de saída.

Tente alterar o valor da variável num e observe a mudança na saída.

Por exemplo, consideramos o seguinte programa cujo padrão é:

#include <stdio.h>
int main() {
int language = 10;
  switch (language) {
  case 1:
    printf("C#\n");
    break;
  case 2:
    printf("C\n");
    break;
  case 3:
    printf("C++\n");
    break;
  default:
    printf("Other programming language\n");}}

Saída:

Other programming language

Ao trabalhar com switch case em C, você agrupa vários casos com rótulos exclusivos. Você precisa introduzir uma instrução break em cada caso para ramificar no final de uma instrução switch.

O caso padrão opcional é executado quando nenhuma outra correspondência é feita.

Consideramos a seguinte instrução switch:

#include <stdio.h>
int main() {
int number=5;
switch (number) {
  case 1:
  case 2:
  case 3:
    printf("One, Two, or Three.\n");
    break;
  case 4:
  case 5:
  case 6:
    printf("Four, Five, or Six.\n");
    break;
  default:
    printf("Greater than Six.\n");}}

Saída:

Four, Five, or Six.

Switch aninhado em C

In C, podemos ter um switch interno embutido em um switch externo. Além disso, as constantes de caso da chave interna e externa podem ter valores comuns e sem conflitos.

Consideremos o seguinte programa, que solicita ao usuário que digite seu próprio ID. Se o ID for válido, o programa solicitará que ele insira sua senha; se a senha estiver correta, o programa exibirá o nome do usuário; caso contrário, exibirá "Senha incorreta"; e se o ID não existir, o programa exibirá "ID incorreto".

#include <stdio.h>
int main() {
        int ID = 500;
        int password = 000;
        printf("Plese Enter Your ID:\n ");
        scanf("%d", & ID);
        switch (ID) {
            case 500:
                printf("Enter your password:\n ");
                scanf("%d", & password);
                switch (password) {
                    case 000:
                        printf("Welcome Dear Programmer\n");
                        break;
                    default:
                        printf("incorrect password");
                        break;
                }
                break;
            default:
                printf("incorrect ID");
                break;
        }
}

Saída:

Plese Enter Your ID:
 500
Enter your password:
 000
Welcome Dear Programmer

Switch aninhado em C

  1. No programa em questão, inicializamos duas variáveis: ID e senha.
  2. Uma estrutura switch externa é usada para comparar o valor inserido na variável ID. Ela executa o bloco de instruções associado ao caso correspondente (quando ID==500).
  3. Se o bloco de instruções for executado com o caso correspondente, um switch interno é usado para comparar os valores inseridos na variável password e executar as instruções vinculadas ao caso correspondente (quando password==000).
  4. Caso contrário, o switch case acionará o caso padrão e imprimirá o texto apropriado referente ao esboço do programa.

Por que precisamos de um case Switch?

Existe um problema potencial com o declaração if-else que é a complexidade do programa aumenta sempre que o número de caminhos alternativos aumenta. Se você usar várias construções if-else no programa, um programa poderá se tornar difícil de ler e compreender. Às vezes, pode até confundir o desenvolvedor que escreveu o programa.

A solução para este problema é a instrução switch.

Regras para instrução switch

Siga estas regras ao escrever um switch em C:

  • Uma expressão deve sempre ser executada para um resultado.
  • Os rótulos de caso devem ser constantes e exclusivos.
  • Os rótulos dos casos devem terminar com dois pontos ( : ).
  • Uma palavra-chave break deve estar presente em cada caso.
  • Só pode haver um rótulo padrão.
  • Podemos aninhar várias instruções switch.

Perguntas Frequentes

O interruptor AC aceita apenas valores int, char e enum — nunca floats ou strings, pois cada rótulo deve ser um número inteiro constante.

Sem interrupção, o controle falha e executa todos os casos subsequentes também — às vezes intencionalmente, mas geralmente um bug acidental.

Não. Em C, não é possível usar `switch` em strings; os rótulos devem ser inteiros constantes. Em vez disso, compare o texto com `strcmp` dentro de uma estrutura `if-else`.

A linguagem C padrão proíbe intervalos, embora o GCC permita um caso não portátil de 1 a 5: extensão que o código portátil deve evitar.

Não. O caso padrão pode estar em qualquer lugar; ele só é executado quando nenhum rótulo corresponde. A última posição é mera convenção.

Sim, mas envolva o corpo do caso em chaves; caso contrário, uma declaração após um rótulo pode causar erros de compilação.

Sim. Os assistentes de codificação de IA elaboram blocos de interrupção, adicionam cada quebra e sinalizam falhas acidentais. Sempre revise a lógica gerada.

Copiloto do GitHub Completa automaticamente os rótulos dos casos, insere instruções `break` e converte longas cadeias `if-else` em um `switch` a partir de um comentário.

Resuma esta postagem com: