Branching statements in C

The capacity to decide what to do and how to run distinct pieces of code based on specific circumstances is essential in the realm of programming. This ability to manage the execution flow is provided by branching statements in the C programming language. We'll examine the different branching statements in C in this blog article, going through their syntax, giving examples, and showcasing the results they produce.

Branching statements are mainly categorized as follows.

Conditional Branching Statements
Unconditional Branching Statements

Conditional Branching Statements:

In C, conditional branching statements are used to execute particular code blocks based on a condition (as needed). These branching instructions in C allow programmers to run the code only when specific conditions are met. The various categories of conditional branching statements in C are as follows:

if Statement
if-else Statement
nested if-else Statement
switch Statement

The if Statement:

The most fundamental branching construct in C is the "if" statement. If a given condition is met, it permits the execution of a block of code. The "if" statement has the following syntax:

if (condition) {
   // Code to execute if condition is true
}

Example:

#include <stdio.h>

int main() {
int num = 10;

if (num > 0) {
printf("The number is positive.\n");
}

return 0;
}

Output:

The number is positive.

The if-else Statement:

By offering a different block of code to run when the condition is false, the "if-else" statement builds on the "if" statement. The "if-else" expression has the following syntax:

if (condition) {
   // Code to execute if condition is true
}
else {
   // Code to execute if condition is false
}

Example:

#include <stdio.h>

int main() {
int num = -5;

if (num > 0) {
printf("The number is positive.\n");
}
else {
printf("The number is non-positive.\n");
}

return 0;
}

Output:

The number is non-positive.

The nested if-else Statement:

You can have an "if-else" statement within another "if" or "else" block in C since it supports the nesting of "if-else" statements. It allows for adaptability when managing various environments. The nested "if-else" statement has the following syntax:

if (condition1) {
   // Code to execute if condition1 is true

   if (condition2) {
      // Code to execute if condition2 is true
   }
   else {
      // Code to execute if condition2 is false
   }
}
else {
   // Code to execute if condition1 is false
}

Example:

#include <stdio.h>

int main() {
int num = 0;

if (num > 0) {
printf("The number is positive.\n");
}
else if (num < 0) {
printf("The number is negative.\n");
}
else {
printf("The number is zero.\n");
}

return 0;
}

Output:

The number is zero.

The switch Statement:

Multiple actions can be taken using the "switch" statement based on the value of a variable or expression. When managing several instances, it is especially helpful. The "switch" statement has the following syntax:

 switch (expression) {
   case constant1:
      // Code to execute if expression matches constant1
      break;
   case constant2:
      // Code to execute if expression matches constant2
      break;
   // More cases...
   default:
      // Code to execute if expression doesn't match any constant
}

Example:

#include <stdio.h>

int main() {
int day = 3;

switch (day) {
case 1:
printf("Monday\n");
break;
case 2:
printf("Tuesday\n");
break;
case 3:
printf("Wednesday\n");
break;
case 4:
printf("Thursday\n");
break;
case 5:
printf("Friday\n");
break;
default:
printf("Invalid day\n");
}

return 0;
}

Output:

Wednesday

Unconditional Branching Statements:

C uses unconditional branching statements to alter the typical course of program execution. These statements give programmers the freedom to jump to a specific location in their code under any circumstance. The various categories of unconditional branching statements in C are as follows:

goto Statement
break Statement
continue Statement

goto Statement:

The "goto" command enables programmers to leap directly to a designated labelled statement within their code. It is an unconditional branching statement.

Syntax of goto Statement in C:

goto label;

...

label:
    // code to be executed

The "goto" statement executes the code in the block following a jump to the "label"-labeled statement. Any legal identifier can be used as the "label" after a colon (:).

Example:

It is an illustration of a goto statement.

#include <stdio.h>

int main() {
   int num = 1;

   if (num == 1) {
goto label;
   }

printf("This statement is skipped.\n");

   label:
printf("The value of num is 1.\n");

   return 0;
}

Output:

The value of num is 1.

Explanation:

In this example, the 'goto' statement switches control to the labelled statement 'label', skipping the succeeding printf statement, when the condition num == 1 is true. Only the line "The value of num is 1" is printed consequently

The 'break' Statement:

The "break" statement is frequently employed in switch statements as well as looping constructions like "for", "while", and "do-while". It enables you to skip the statement that follows the loop or switch and end the execution of the closest enclosing loop or switch statement.

The "break" statement in C is written in the following syntax.

Example:

Look at the following illustration of the 'break' statement in use within a loop:

#include <stdio.h>

int main() {
   int i;

   for (i = 1; i<= 5; i++) {
      if (i == 3) {
         break;
      }
printf("%d ", i);
   }

   return 0;
}

Output:

1 2

Explanation:

In this illustration, the 'for' loop iterates from 1 to 5. However, the 'break' statement is encountered when i equals 3, ending the loop early. Only the numerals 1 and 2 are printed as a result.

continue Statement

In the C programming language, the continue statement is used to go to the next iteration of a loop while skipping the current iteration. Usually, this statement is used in loops like for or while.

Syntax of continue statement in C is as follows:

When a loop encounters the continue statement, the current iteration of the loop is ended, and control is returned to the top of the loop to begin the subsequent iteration.

Example:

This sample demonstrates how the C continues Statement functions.

#include <stdio.h>


int main() {
    int i;

    for (i = 0; i< 10; i++) {
        if (i % 2 == 0) {
            continue; // skip even numbers
        }

printf("%d ", i);
    }

    return 0;
}

Output:

1 3 5 7 9

Explanation:

In the above example, the for loop iterates from 0 to 9, and when the loop variable i is even, the continue statement is executed and control is transferred to the following iteration of the loop. As a result, the printf statement only prints odd integers and skips over even values.

Advantages and Disadvantages of Branching Statements

There are various advantages and disadvantages of the branching statements. Some main advantages and disadvantages of the branching statements are as follows:

Advantages of Branching Statements:

Better Decision Making: Branching statements give programmers the ability to decide what to do next in their code depending on certain circumstances. It improves the program's functionality and versatility by allowing it to respond and adapt to various conditions.

Readability of the code: Branching statements make the logic of the code clearer and simpler to understand. For other developers to understand and maintain the codebase, the conditional statements provide distinct signs of the program's decision-making process.

Code effectiveness: Branching statements optimize program execution by only running the necessary code blocks in accordance with the predetermined circumstances. It can make programs run more quickly and effectively, especially when employing the "switch" statement to process big sets of cases or complex decision trees.

Flexibility: Programming flexibility is provided through branching statements, which enables several code paths to be performed in response to diverse circumstances. This adaptability is especially helpful when the program needs to react quickly to altering inputs or outside influences.

Code Reusability: Branching statements make it easier to reuse code by enabling the execution of code blocks in response to various situations. Programmers can create modular code that can be easily reused in various portions of the program by utilizing branching statements efficiently.

Disadvantages of Branching Statements:

Code Complexity: When branching statements are overused or deeply nested, the code may become clearer and easier to comprehend. It may result in maintenance problems, defects, and poorer-quality code. It's crucial to utilize branching statements sparingly and aim for simplicity.

Readability Issues: Although branching statements can sometimes make code easier to comprehend, they can also cause issues if used carelessly. The code may become more difficult to read and understand if there are too many nested levels, complex conditional expressions, or duplicative sections of code.

Potential for Logical Mistakes: If the conditions are not adequately established and validated, branching statements run the danger of logical mistakes.

Code Maintenance: The intricacy of branching statements makes it more difficult to maintain the code. It can be difficult to comprehend the logic of the code and make the necessary adjustments without adding problems when there are numerous branching statements and nested conditions present.

Let's look at a few more instances to see how branching statements are used in various contexts:

Example 1: Finding the Maximum Number

#include <stdio.h>

int main() {
int num1 = 10;
int num2 = 20;
int max;

if (num1 > num2) {
max = num1;
}
else {
max = num2;
}

printf("The maximum number is: %d\n", max);

return 0;
}

Output:

The maximum number is: 20

Explanation:

In this illustration, the maximum value is established by comparing two numbers (num1 and num2) using the "if-else" expression. The program sets the variable max to its maximum value before displaying it on the terminal.

Example 2: Grade Classification

#include <stdio.h>

int main() {
int marks;

printf("Enter the marks: ");
scanf("%d", &marks);

if (marks >= 90) {
printf("Grade: A\n");
}
else if (marks >= 80) {
printf("Grade: B\n");
}
else if (marks >= 70) {
printf("Grade: C\n");
}
else if (marks >= 60) {
printf("Grade: D\n");
}
else {
printf("Grade: F\n");
}

return 0;
}

Output (for input 78):

Grade: C

Explanation:

In this illustration, the program accepts the user's marks as input and determines the grade level using the "if-else if" ladder. The program prints the corresponding grade on the console based on the input marks.

Example 3: Month Name

#include <stdio.h>

int main() {
int monthNumber;

printf("Enter the month number (1-12): ");
scanf("%d", &monthNumber);

switch (monthNumber) {
case 1:
printf("January\n");
break;
case 2:
printf("February\n");
break;
case 3:
printf("March\n");
break;
case 4:
printf("April\n");
break;
case 5:
printf("May\n");
break;
case 6:
printf("June\n");
break;
case 7:
printf("July\n");
break;
case 8:
printf("August\n");
break;
case 9:
printf("September\n");
break;
case 10:
printf("October\n");
break;
case 11:
printf("November\n");
break;
case 12:
printf("December\n");
break;
default:
printf("Invalid month number\n");
}

return 0;
}

Output (for input 8):

August

Explanation:

In this illustration, the computer receives the user's input as the month number and then utilizes the "switch" statement to get the name of the matching month. The program prints the corresponding month name on the console based on the input.

Example 4: Leap Year Check

#include <stdio.h>

int main() {
int year;

printf("Enter the year: ");
scanf("%d", &year);

if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
printf("%d is a leap year.\n", year);
}
else {
printf("%d is not a leap year.\n", year);
}

return 0;
}

Output (for input 2024):

2024 is a leap year.

Explanation:

In the above example, the for loop iterates from 0 to 9, and when the loop variable i is even, the continue statement is executed and control is transferred to the following iteration of the loop. As a result, the printf statement only prints odd integers and skips over even values.

Conclusion:

Programmers often use branching statements because they give them the power to modify how code is executed based on certain criteria. In this blog post, we focused on the "if", "if-else", nested "if-else", and "switch" expressions to examine the fundamental branching statements in the C programming language.

The "if-else" statement expands on the "if" statement's ability to execute code conditionally by offering an additional code block for when the condition is false. Decision-making is more flexible because numerous criteria may be handled within nested blocks due to the nested "if-else" statement. Finally, the "switch" statement simplifies managing many situations by enabling alternative actions to be carried out depending on the value of a variable or expression.

Learning how to use these branching statements gives programmers more control over how their programs run, allowing them to create applications that are more intelligent and dynamic. It is crucial to experiment with various conditions and scenarios to gain a deeper grasp of and increase one's expertise with branching statements efficiently.

As you advance in your understanding of C programming, keep in mind that branching statements are effective tools that improve the flexibility and logic of the code. With time and practice, you will develop the abilities needed to make the best decisions and build solid, effective programs.

Next TopicBubble Sort in C

← prev next →