A instrução switch em C é uma alternativa à instrução ladder if-else-if que nos permite executar múltiplas operações para os diferentes valores possíveis de uma única variável chamada variável switch. Aqui, podemos definir várias declarações nos múltiplos casos para os diferentes valores de uma única variável.

A sintaxe da instrução switch em linguagem c é dado abaixo:

 switch(expression){ case value1: //code to be executed; break; //optional case value2: //code to be executed; break; //optional ...... default: code to be executed if all cases are not matched; } 

Regras para instrução switch em linguagem C

1. O expressão de mudança deve ser de um tipo inteiro ou de caractere.
2. O valor do caso deve ser um número inteiro ou uma constante de caractere.
3. O valor do caso pode ser usado somente dentro da instrução switch.
4. O declaração de interrupção no caso do switch não é obrigatório. É opcional. Se não houver nenhuma instrução break encontrada no caso, todos os casos serão executados presentes após o caso correspondente. É conhecido como Cair em o estado da instrução switch C.

Vamos tentar entender pelos exemplos. Estamos assumindo que existem as seguintes variáveis.

 int x,y,z; char a,b; float f; 

Fluxograma da instrução switch em C

Funcionamento da instrução switch case

Primeiro, a expressão inteira especificada na instrução switch é avaliada. Este valor é então comparado um por um com os valores constantes dados nos diferentes casos. Se uma correspondência for encontrada, todas as instruções especificadas nesse caso serão executadas junto com todos os casos presentes após esse caso, incluindo a instrução padrão. Não há dois casos que possam ter valores semelhantes. Se o caso correspondente contiver uma instrução break, todos os casos presentes depois disso serão ignorados e o controle sairá do switch. Caso contrário, todos os casos seguintes ao caso correspondente serão executados.

Como funciona a instrução C switch?

Vamos seguir o processo passo a passo de como a instrução switch funciona em C:

Considere o seguinte declaração de mudança :

Programa C:

 #include int main() { int num = 2; switch (num) { case 1: printf('Value is 1
'); break; case 2: printf('Value is 2
'); break; case 3: printf('Value is 3
'); break; default: printf('Value is not 1, 2, or 3
'); break; } return 0; } 

Saída

 Value is 2 

Processo passo a passo:

1. O mudar variável num é avaliado. Nesse caso, num é inicializado com o valor 2 .
2. O valor avaliado num (2) é comparado com as constantes especificadas em cada rótulo de caso dentro do bloco de comutação .
3. O declaração de mudança corresponde ao valor avaliado (2) com a constante especificada no segundo caso (caso 2) . Como há uma correspondência, o programa salta para o bloco de código associado ao caso correspondente (caso 2) .
4. O bloco de código associado a caso 2 é executado, que imprime 'O valor é 2' para o console.
5. O 'quebrar' palavra-chave está presente no bloco de código de caso 2 . Como resultado, o programa interrompe a instrução switch imediatamente após a execução do bloco de código.
6. O controle do programa continua após o declaração de mudança e quaisquer declarações após o declaração de mudança são executados. Nesse caso, não há instruções após a troca, então o programa termina.
7. O declaração de mudança avaliou o valor do variável num , encontrou uma correspondência com o caso 2, executou o bloco de código correspondente e saiu do bloco de comutação devido à presença do declaração de 'quebra' .

Exemplo de uma instrução switch em C

Vejamos um exemplo simples de uma instrução switch em linguagem C.

 #include int main(){ int number=0; printf('enter a number:'); scanf('%d',&number); switch(number){ case 10: printf('number is equals to 10'); break; case 50: printf('number is equal to 50'); break; case 100: printf('number is equal to 100'); break; default: printf('number is not equal to 10, 50 or 100'); } return 0; } 

Saída

classificar arraylist em java

 enter a number:4 number is not equal to 10, 50 or 100 enter a number:50 number is equal to 50 

Exemplo de caso de mudança 2

 #include int main() { int x = 10, y = 5; switch(x>y && x+y>0) { case 1: printf('hi'); break; case 0: printf('bye'); break; default: printf(' Hello bye '); } } 

Saída

 hi 

Palavra-chave Break e Default na instrução Switch

Vamos explicar e definir o 'quebrar' e palavras-chave 'padrão' no contexto da instrução switch, juntamente com código de exemplo e saída.

1. Quebrar palavra-chave:

O palavra-chave 'quebrar' é usado dentro do bloco de código de cada caso para encerrar a instrução switch prematuramente. Quando o programa encontra um declaração de 'quebra' dentro de um bloco case, ele sai imediatamente do declaração de mudança , impedindo a execução de blocos de casos subsequentes. O declaração de 'quebra' é crucial para evitar declarações switch' 'Cair em' comportamento.

Exemplo:

Vamos pegar um programa para entender o uso do palavra-chave break em C.

 #include int main() { int num = 3; switch (num) { case 1: printf('Value is 1
'); break; // Exit the switch statement after executing this case block case 2: printf('Value is 2
'); break; // Exit the switch statement after executing this case block case 3: printf('Value is 3
'); break; // Exit the switch statement after executing this case block default: printf('Value is not 1, 2, or 3
'); break; // Exit the switch statement after executing the default case block } return 0; } 

Saída

 Value is 3 

Explicação:

Neste exemplo, o declaração de mudança avalia o valor do variável num (qual é 3 ) e combina com caso 3 . O bloco de código associado a caso 3 é executado, imprimindo 'O valor é 3' para o console. O declaração de 'quebra' dentro de caso 3 garante que o programa saia da instrução switch imediatamente após a execução deste bloco case, evitando a execução de quaisquer outros casos.

2. Palavra-chave padrão:

Quando nenhum dos constantes de caso combinar com o expressão avaliada , funciona como um caso pega-tudo . Se não existir nenhum caso correspondente e um caso 'padrão' existe , o bloco de código associado ao 'padrão' caso é executado. É frequentemente usado para lidar com circunstâncias em que nenhuma das situações declaradas se aplica à entrada fornecida.

Exemplo:

Vamos pegar um programa para entender o uso do palavra-chave padrão em C.

 #include int main() { int num = 5; switch (num) { case 1: printf('Value is 1
'); break; case 2: printf('Value is 2
'); break; case 3: printf('Value is 3
'); break; default: printf('Value is not 1, 2, or 3
'); break; // Exit the switch statement after executing the default case block } return 0; } 

Saída

 Value is not 1, 2, or 3 

Explicação:

Neste exemplo, o declaração de mudança examina o valor do variável num (qual é 5 ). Como nenhum caso corresponde ao num, o programa executa o bloco de código associado ao caso 'padrão' . O declaração de 'quebra' dentro de caso 'padrão' garante que o programa saia do declaração de mudança depois de executar o 'padrão' bloco de casos.

Tanto o 'quebrar' e palavras-chave 'padrão' desempenham papéis essenciais no controle do fluxo de execução dentro de uma instrução switch. O declaração de 'quebra' ajuda a prevenir o comportamento de queda, enquanto o caso 'padrão' fornece uma maneira de lidar com casos incomparáveis.

A instrução C Switch é falha

Na linguagem C, a instrução switch falha; isso significa que se você não usar uma instrução break no switch case, todos os casos após o case correspondente serão executados.

Vamos tentar entender o estado de queda da instrução switch pelo exemplo abaixo.

 #include int main(){ int number=0; printf('enter a number:'); scanf('%d',&number); switch(number){ case 10: printf('number is equal to 10
'); case 50: printf('number is equal to 50
'); case 100: printf('number is equal to 100
'); default: printf('number is not equal to 10, 50 or 100'); } return 0; } 

Saída

 enter a number:10 number is equal to 10 number is equal to 50 number is equal to 100 number is not equal to 10, 50 or 100 

Saída

 enter a number:50 number is equal to 50 number is equal to 100 number is not equal to 10, 50 or 100 

Instrução switch case aninhada

Podemos usar quantas instruções switch quisermos dentro de uma instrução switch. Esse tipo de instrução é chamado de instrução switch case aninhada. Considere o seguinte exemplo.

 #include int main () { int i = 10; int j = 20; switch(i) { case 10: printf('the value of i evaluated in outer switch: %d
',i); case 20: switch(j) { case 20: printf('The value of j evaluated in nested switch: %d
',j); } } printf('Exact value of i is : %d
', i ); printf('Exact value of j is : %d
', j ); return 0; } 

Saída

 the value of i evaluated in outer switch: 10 The value of j evaluated in nested switch: 20 Exact value of i is : 10 Exact value of j is : 20 

Vantagens da instrução switch:

Existem diversas vantagens do declaração de mudança em C. Algumas vantagens principais da instrução switch são as seguintes:

Legibilidade e clareza:O declaração de mudança fornece uma maneira concisa e direta de expressar ramificação multidirecional no código. Lidar com vários casos pode tornar o código mais organizado e mais fácil de ler do que vários casos. instruções if-else aninhadas .Eficiência:O declaração de mudança geralmente é mais eficiente do que uma série de declarações if-else ao lidar com múltiplas condições. Funciona como um d tabela de salto direto , o que o torna mais rápido e otimizado em termos de tempo de execução.Lógica baseada em casos:O declaração de mudança ajusta-se naturalmente a cenários onde o programa precisa tomar decisões com base em valores específicos de uma única variável. É uma maneira intuitiva e direta de implementar lógica baseada em casos.

O declaração de mudança suporta o uso de um caso padrão que serve como um opção pega-tudo para valores que não correspondem a nenhum dos casos fornecidos. Esse caso padrão lida com informações ou circunstâncias incomuns que não são expressamente declaradas.

Desvantagens da instrução switch:

Existem várias desvantagens do declaração de mudança em C. Algumas desvantagens principais da instrução switch são as seguintes:

Expressões limitadas:A expressão usada no declaração de mudança deve resultar em valor integral (char, int, enum) ou um tipo de dados compatível. Não aguenta mais expressões complexas ou não constantes , limitando seu flexibilidade em alguns cenários.Incapacidade de comparar intervalos:Diferente declarações if-else , o declaração de mudança não pode lidar com intervalos de valores diretamente. Cada caso na instrução switch representa um valor constante específico, tornando difícil lidar com um intervalo de valores de forma eficiente.Não há suporte para números de ponto flutuante:O declaração de mudança só aceita tipos integrais (inteiros) e valores de enumerações ; ele não aceita números de ponto flutuante. Não dá conta tipos de dados não integrais como inteiros de ponto flutuante , o que pode ser problemático em algumas circunstâncias.Comportamento de queda: Declarações de mudança ter 'Cair em' comportamento por padrão, o que implica que se um caso não incluir um declaração de 'quebra' , a execução será 'Cair em' para o seguinte bloco de caso. Se não for gerenciado adequadamente, isso poderá resultar em comportamento indesejado.Código duplicado:Usando um declaração de mudança pode resultar em código duplicado em algumas circunstâncias, especialmente quando vários casos exigem as mesmas ações. Se não for gerenciado adequadamente, isso poderá resultar na duplicação de código.Os switches aninhados podem se tornar complexos:Ao lidar com aninhado instruções de troca , o código pode se tornar complexo e menos legível. Pode ser necessário um esforço adicional para compreender e manter essas estruturas aninhadas.