Switch Statement in C

The switch statement in C is an alternate to if-else-if ladder statement which allows us to execute multiple operations for the different possibles values of a single variable called switch variable. Here, We can define various statements in the multiple cases for the different values of a single variable.

Syntax of a Switch Statement

The basic syntax of a switch statement in C is as follows:

c
switch (expression) {
    case constant1:
        // Code to execute when expression equals constant1
        break;
    case constant2:
        // Code to execute when expression equals constant2
        break;
    // More cases can be added as needed
    default:
        // Code to execute when expression doesn't match any case
}

Here's an explanation of each part:

1. switch: The keyword that starts the switch statement.
2. expression: The value that is evaluated to determine which case to execute.
3. case: A keyword that labels a specific case to match against the expression.
4. constant1, constant2, etc.: Constants or literal values that are compared to the expression.
5. break: A keyword that ends the execution of the switch statement once a case is matched.

6. default: An optional case that is executed when no other case matches the expression

7. default: An optional case that is executed when no other case matches the expression.

   Rules for switch statement in C language

   1) The switch expression must be of an integer or character type.
   
   2) The case value must be an integer or character constant.
   
   3) The case value can be used only inside the switch statement.
   
   4) The break statement in switch case is not must. It is optional. If there is no break statement found in the case, all the cases will be executed present after the matched case. It is known as fall through the state of C switch statement.
   
   Let's try to understand it by the examples. We are assuming that there are following variables.
    

   1. int x,y,z;  
   2. char a,b;  
   3. float f;  

      Valid Switch	Invalid Switch	Valid Case	Invalid Case
      switch(x)	switch(f)	case 3;	case 2.5;
      switch(x>y)	switch(x+2.5)	case 'a';	case x;
      switch(a+b-2)		case 1+2;	case x+2;
      switch(func(x,y))		case 'x'>'y';	case 1,2,3;

   Flowchart of switch statement in C

   

   
   

   How a Switch Statement Works

   When you use a switch statement, the expression is evaluated once, and the program flow jumps to the matching case label. Once the code block for that case is executed, it continues until a break statement is encountered or the end of the switch statement is reached. If no case matches the expression, the code within the default block (if present) is executed.Switch statements are commonly used with integral types (e.g., int, char, enum) but not with floating-point numbers or strings. Each case label should be a constant that can be evaluated at compile time.

   Example 1: Simple Switch Statement

   Let's start with a simple example of a switch statement that takes an integer input and prints a corresponding message based on the input:

   c
   #include <stdio.h>
   
   int main() {
       int choice;
       printf("Enter a number (1-3): ");
       scanf("%d", &choice);
   
       switch (choice) {
           case 1:
               printf("You chose One.\n");
               break;
           case 2:
               printf("You chose Two.\n");
               break;
           case 3:
               printf("You chose Three.\n");
               break;
           default:
               printf("Invalid choice.\n");
       }
   
       return 0;
   }

   In this example, the user enters a number, and the program uses a switch statement to determine which message to print based on the value of choice.

   Example 2: Using a Switch Statement with Enum

   You can also use switch statements with enum types, which provide symbolic names for a set of integral constants. Here's an example:

   c
   #include <stdio.h>
   
   enum Day { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };
   
   int main() {
       enum Day today = Wednesday;
   
       switch (today) {
           case Sunday:
               printf("It's Sunday!\n");
               break;
           case Monday:
               printf("It's Monday!\n");
               break;
           case Tuesday:
               printf("It's Tuesday!\n");
               break;
           case Wednesday:
               printf("It's Wednesday!\n");
               break;
           case Thursday:
               printf("It's Thursday!\n");
               break;
           case Friday:
               printf("It's Friday!\n");
               break;
           case Saturday:
               printf("It's Saturday!\n");
               break;
       }
   
       return 0;
   }

   In this example, we define an enum Day with days of the week and use it to determine the day based on the value of today.

   Example 3: Using Fall-Through

   By default, a switch statement executes only the code block associated with the first matching case. However, you can use fall-through to execute code for multiple cases. Here's an example:

   c
   #include <stdio.h>
   
   int main() {
       int choice = 2;
   
       switch (choice) {
           case 1:
               printf("You chose One.\n");
               break;
           case 2:
           case 3:
               printf("You chose Two or Three.\n");
               break;
           default:
               printf("Invalid choice.\n");
       }
   
       return 0;
   }

   In this example, when choice is 2 or 3, the code block associated with both cases is executed because there is no break statement after case 2. This behavior is called fall-through.

   Best Practices and Considerations

   While switch statements are useful, there are some best practices and considerations to keep in mind:
   
   1. Always include a default case: It's a good practice to have a default case to handle unexpected values or edge cases.
   
   
   2. Use break statements: Make sure to include break statements in each case to prevent fall-through unless you explicitly want it.
   
   
   3. Avoid complex expressions: The expression in a switch statement should be simple and easily evaluated.
   
   
   4. Use enum for readability: When dealing with a set of related integer constants, consider using an enum for improved code readability.
   
   
   5. Keep it concise: Avoid long, complex switch statements. If a switch becomes too long, consider refactoring your code.
   
   
   6. Use switch for multiple cases: If you only have two cases, an if-else statement might be more readable.
   
   7. Consider alternatives: In some cases, if-else chains or other control structures may be more appropriate than a switch.
   
   Conclusion
   
   The switch statement in C is a powerful tool for handling multiple conditions in a concise and efficient way. It allows you to choose from a list of options based on the value of an expression. By following best practices and understanding how switch statements work, you can use them effectively in your C programs to make your code more readable and maintainable.