Nested If Else Best Example In C

When developing programs in C, decision-making structures are fundamental for controlling program flow based on conditions. The if-else statement allows execution of different code blocks depending on whether a condition is true or false. Often, scenarios arise where a condition's evaluation depends on the outcome of a preceding condition, leading to the use of nested if-else statements.

In this article, you will learn how to effectively use nested if-else statements in C to handle complex decision-making logic, with a practical example of a student grading system.

Problem Statement

Many real-world applications require evaluating multiple, dependent conditions before arriving at a final decision. For instance, a simple grading system might first need to confirm that a student's score is valid (e.g., between 0 and 100) before determining their letter grade (A, B, C, D, F). If the score itself is invalid, attempting to assign a grade becomes meaningless. This hierarchical decision-making is where nested if-else structures become essential for maintaining logical integrity and preventing errors.

Example

Consider a scenario where a program needs to take a student's score as input and output their corresponding grade. If the score is outside the valid range (0-100), it should indicate an invalid input. Otherwise, it should assign a grade (A, B, C, D, F) based on predefined thresholds.

For example:

• Input: 85 -> Output: Grade: B
• Input: 105 -> Output: Invalid score entered.

Background & Knowledge Prerequisites

To understand nested if-else statements, you should be familiar with:

• C Language Basics: Fundamental syntax, variable declaration, input/output operations using printf and scanf.
• if-else Statements: How basic conditional statements work to execute code blocks based on a single condition.
• Comparison Operators: Operators like >, <, >=, <=, ==, != used for evaluating conditions.

No special imports beyond stdio.h are typically required for basic if-else logic.

Use Cases or Case Studies

Nested if-else structures are widely applicable in various programming scenarios where decisions are multi-layered:

• Eligibility Checks: Determining if a person is eligible for a loan, voting, or a discount based on age, income, and other factors. For example, if (age >= 18) { if (has_ID) { ... } }.
• Menu-Driven Programs: Handling user choices in a hierarchical menu where selecting a main option leads to sub-options.
• Game Logic: Implementing AI behaviors or game state transitions where certain actions are only possible under specific conditions (e.g., if (player_has_key) { if (door_is_locked) { unlock_door(); } }).
• Input Validation: As seen in the problem statement, validating input data before processing it further (e.g., checking if an entered number is within an expected range before performing calculations).
• Traffic Light Control: Simulating a traffic light system where light changes depend on the state of other lights or pedestrian requests.

Solution Approaches

Grading System with Nested If-Else

This approach demonstrates how to use nested if-else statements to validate a student's score and then assign a grade based on that valid score. The outer if statement checks for score validity, and the inner if-else if ladder determines the specific grade.

// Student Grading System with Nested If-Else
#include <stdio.h>

int main() {
    int score;

    // Step 1: Prompt user for input
    printf("Enter student's score (0-100): ");

    // Step 2: Read the score from user
    scanf("%d", &score);

    // Step 3: Outer if-else for score validation
    if (score >= 0 && score <= 100) {
        // Step 4: Inner if-else if ladder for grade assignment
        if (score >= 90) {
            printf("Grade: A\\n");
        } else if (score >= 80) {
            printf("Grade: B\\n");
        } else if (score >= 70) {
            printf("Grade: C\\n");
        } else if (score >= 60) {
            printf("Grade: D\\n");
        } else {
            printf("Grade: F\\n");
        }
    } else {
        // Step 5: Handle invalid score
        printf("Invalid score entered. Score must be between 0 and 100.\\n");
    }

    return 0;
}

Run

Sample Output 1 (Valid Score):

Enter student's score (0-100): 85
Grade: B

Sample Output 2 (Invalid Score):

Enter student's score (0-100): 105
Invalid score entered. Score must be between 0 and 100.

Stepwise Explanation:

1. Include Header: The stdio.h header is included for standard input/output functions like printf and scanf.
2. Declare Variable: An integer variable score is declared to store the student's marks.
3. Get Input: The program prompts the user to enter a score and reads it using scanf.
4. Outer if (Validation): The first if statement checks if the score is within the valid range (0 to 100) using a logical AND (&&) operator.

• if (score >= 0 && score <= 100): If this condition is true, it means the score is valid, and the program proceeds to determine the grade.
• else: If the condition is false, the score is invalid, and the else block directly prints an error message.

1. Inner if-else if Ladder (Grading): This block is executed *only if* the outer if condition (valid score) is true. It's an if-else if ladder that checks for different grade thresholds in descending order:

• if (score >= 90): Assigns 'A' if score is 90 or above.
• else if (score >= 80): Assigns 'B' if score is 80-89.
• else if (score >= 70): Assigns 'C' if score is 70-79.
• else if (score >= 60): Assigns 'D' if score is 60-69.
• else: If none of the above conditions are met (meaning score is between 0-59), it assigns 'F'.

1. Return 0: The main function returns 0, indicating successful program execution.

Conclusion

Nested if-else statements provide a powerful way to implement complex decision logic in C programming. They are particularly useful when the evaluation of subsequent conditions depends on the outcome of a primary condition, ensuring that the program follows a logical flow and handles different scenarios robustly. By structuring your code with nested conditions, you can create more organized, readable, and error-resistant applications.

Summary

• Nested if-else statements allow for hierarchical decision-making, where one condition depends on another.
• They are crucial for scenarios like input validation followed by further processing.
• The outer if typically validates a primary condition, while inner if-else blocks handle specific cases when the primary condition is met.
• Using nested if-else improves code structure and logic for complex conditional flows.
• The example of a student grading system illustrates validating a score before assigning a grade.