Nested if else statement in C

A nested if-else statement syntax in C involves placing one if statement inside another, enabling you to evaluate multiple conditions in a structured way. Using a nested if-else statement with an example, you can handle more complex decision-making processes based on these nested conditions.

This guide simplifies nested if-else statements in C, making it easier to handle multiple conditions.

Let’s dive into the details!

Boost your C programming skills with our Software Development courses — take the next step in your learning journey! 

Syntax of a Nested If-Else Statement

A nested if-else statement in C allows you to check multiple conditions in a hierarchical way, where an if-else structure is placed inside another if or else block. This makes it possible to evaluate complex conditions in a single decision-making structure.

Here’s the basic nested if-else statement syntax:

if (condition1) {
    if (condition2) {
        // Action if both conditions are true
    } else {
        // Action if condition1 is true and condition2 is false
    }
} else {
    // Action if condition1 is false
}

Explanation of the Structure:

• Outer if statement: This is the first if that checks the primary condition (condition1). If condition1 evaluates to true, it moves to the inner if statement. If condition1 is false, the else part of the outer if executes.

• Inner if-else statement: The inner if checks a secondary condition (condition2). If condition2 is true, the corresponding action is executed. If condition2 is false, the else block within the inner statement executes.
• Outer else block: This part runs if the outer if condition evaluates to false, meaning condition1 is false. In this case, no need to check condition2, and the action specified here will execute.

To visualize the flow, let's look at a simple flowchart of a nested if-else statement:

Let’s look at the nested if-else statement with an example. This example will check whether a number is positive or negative and, if positive, whether it's even or odd. 

#include <stdio.h>
int main() {
    int number = 12; // Initial number
    if (number > 0) {  // Outer if: Check if the number is positive
        if (number % 2 == 0) {  // Inner if: Check if the positive number is even
            printf("The number is positive and even.\n");
        } else {  // Inner else: If the positive number is odd
            printf("The number is positive and odd.\n");
        }
    } else if (number < 0) {  // Outer else-if: Check if the number is negative
        printf("The number is negative.\n");
    } else {  // Else for zero
        printf("The number is zero.\n");
    }
    return 0;
}

Output: 

The number is positive and even.

Explanation:

• if (number > 0): The outer if checks if the number is greater than zero, which it is (12). So, it moves to the inner if.
• if (number % 2 == 0): The inner if checks if the number is even. Since 12 is even, the output will be "The number is positive and even."
• else if (number < 0): This block would execute if the number were negative, but it’s skipped in this case because the number is positive.
• else: This block handles the case when the number is zero, but it’s skipped because the number is neither zero nor negative.

Nested if-else statements are useful in real-world scenarios where conditions depend on each other. Read on to know when to use them. 

When to Use a Nested If-Else Statement

A nested if-else statement is particularly useful when you need to evaluate multiple conditional statements that depend on each other. 

This allows you to handle more complex logic in your program, making it ideal for situations where a decision needs to be based on several factors.

Use Cases

• Checking Multiple Conditions: When you need to check a series of interdependent conditions, nested if-else statements let you do this clearly.
• Making Complex Decisions: For scenarios where one condition leads to another and each condition has a different action, nested if-else helps keep the code organized.

Some common real-world situations where nested if-else statements with examples are beneficial include:

• If you want to classify a student’s grade based on their score, check different ranges for grades such as A, B, C, etc.
• Classifying a person’s eligibility for voting, where age must be above 18 and citizenship status must be verified.

Now, let’s take a closer look at an advanced real-life implementation of a nested if-else statement example. In this example, we will check whether a person is eligible for a loan based on their age and income. 

The eligibility criteria are:

• Age should be between 18 and 60 years.
• Monthly income should be at least $2000.
• If age and income are valid, check if the credit score is above 700 for loan approval. 

#include <stdio.h>
int main() {
    int age = 25;  // Person's age
    int income = 2500;  // Person's monthly income
    int credit_score = 720;  // Person's credit score
    if (age >= 18 && age <= 60) {  // Check if age is valid
        if (income >= 2000) {  // Check if income is valid
            if (credit_score >= 700) {  // Check if credit score is sufficient
                printf("Loan Approved.\n");
            } else {  // Credit score is less than 700
                printf("Loan Denied: Low Credit Score.\n");
            }
        } else {  // Income is less than $2000
            printf("Loan Denied: Insufficient Income.\n");
        }
    } else {  // Age is outside valid range
        printf("Loan Denied: Invalid Age.\n");
    }
    return 0;
}

Output: 

Loan Approved.

Explanation:

• if (age >= 18 && age <= 60): The outer if checks if the person’s age is within the valid range (18 to 60). If true, it moves to the inner if to check the income.
• if (income >= 2000): The second if checks if the monthly income is greater than or equal to $2000. If true, it checks the credit score.
• if (credit_score >= 700): The innermost if checks if the credit score is 700 or above. If true, the loan is approved.
• Else statements: If any of the conditions fail (age, income, or credit score), the program prints the corresponding reason for the loan denial.

Also Read: Top 3 Open Source Projects for C [For Beginners To Try]

Now that you know when to make the most of a nested if-else statement, let’s tackle some common pitfalls and how to steer clear of them. 

Common Pitfalls and How to Avoid Them

It's easy to make mistakes when working with nested if-else statement syntax. Below are some common pitfalls and best practices for avoiding them to ensure that your code remains clean, efficient, and easy to maintain.

Common Mistakes:

1. Forgetting to Close Curly Braces

One of the most common mistakes is forgetting to properly close curly braces, which can lead to syntax errors or unexpected behavior. Always ensure that every opening { has a corresponding closing }.

Example:

if (condition) {
    // code
// Missing closing brace here

2. Improper Indentation

Consistent indentation is critical for readability. When nesting if-else statements, improper indentation can make the logic hard to follow. Always use consistent indentation (e.g., 4 spaces or a tab).

Example:

if (condition) {
    if (anotherCondition) {
        // code
    }
}

3. Overly Complex Nesting

Deeply nested if-else statements can make code difficult to read and debug. Limit the nesting depth to avoid confusion. If your logic is becoming too complex, refactor it into smaller, more manageable functions.

Example:

if (condition1) {
    if (condition2) {
        if (condition3) {
            // Too deep – consider refactoring
        }
    }
}

Best Practices:

1. Proper Indentation

Use consistent and proper indentation to clearly demarcate different blocks of logic. This makes the flow of your code easier to understand.

Example:

if (condition1) {
    if (condition2) {
        // Inner block for condition2
    } else {
        // Action for condition2 false
    }
} else {
    // Action for condition1 false
}

2. Limit Nesting Depth

Keep the nesting depth to a minimum. If you go more than three levels deep, consider refactoring the logic into separate functions to improve readability and maintainability.

Example: 

Instead of:

if (x > 0) {
    if (y < 10) {
        if (z == 5) {
            // Deeply nested logic
        }
    }
}

Refactor into:

if (x > 0 && y < 10) {
    processZ(z);
}

3. Refactor Complex Logic

Break down complicated logic into smaller, reusable functions. This will not only make your code easier to follow but will also reduce redundancy and improve maintainability.

Example:

Instead of:

if (num > 0) {
    if (num % 2 == 0) {
        // Action for positive and even number
    }
}

Refactor into:

if (num > 0) {
    checkEven(num);
}

void checkEven(int num) {
    if (num % 2 == 0) {
        // Action for even number
    }
}

4. Handle Edge Cases

Ensure that all possible conditions are checked, especially when dealing with user input or external data. Edge cases like null values, boundary conditions, or unexpected inputs can lead to logical errors.

Example:

if (num == NULL) {
    printf("Error: Null value detected.");
} else {
    // Proceed with further checks
}

5. Avoid Redundant Conditions

If similar conditions are being checked repeatedly, it’s better to refactor and remove redundancy. This makes your logic clearer and more efficient.

Example: 

Instead of:

if (num == 1) {
    // action
} else if (num == 2) {
    // action
}

Use:

switch (num) {
    case 1: 
    case 2:
        // action for both 1 and 2
        break;
}

6. Use else if for Mutual Exclusivity

else if instead of multiple if statements makes it clear that only one condition will be executed. This improves the readability and intent of your code.

Example:

if (num == 1) {
    // action
} else if (num == 2) {
    // action
} else {
    // action if neither condition is met
}

Also Read: Top 25+ C Programming Projects for Beginners and Professionals

Nested if-else statement syntax can quickly become messy if not managed properly. By following best practices, you can ensure your code remains clean, readable, and maintainable.

How Well Do You Know Nested If-Else Statements in C? 10 MCQs

This quiz will challenge your understanding of nested if-else statement syntax in C. From basic concepts to more complex applications, let’s see how well you truly grasp the power of nested conditions!

1. What is the primary use of nested if-else statements in C?

A) To create loops within functions

B) To evaluate multiple conditions based on their relationship

C) To define arrays

D) To break out of loops

2. How many levels of nesting are typically recommended in nested if-else statement syntax?

A) 1 level

B) 2-3 levels

C) 5-6 levels

D) Unlimited levels

3. What happens if you miss a closing curly brace in a nested if-else statement?

A) The program will run with warnings

B) The program will not compile and will throw a syntax error

C) The condition will be skipped

D) The program will execute the first block of code

4. In a nested if-else statement example, what is the purpose of the else block?

A) To execute code when the first if condition is true

B) To execute code when none of the conditions are true

C) To execute code when the condition is true

D) To evaluate additional conditions

5. Which of the following is true when using a nested if-else statement with an example?

A) Only the first if condition will ever be executed

B) Only the else part of the structure is executed

C) Multiple conditions can be evaluated sequentially

D) The else block cannot be used

6. How would you improve the readability of complex nested if-else statement syntax?

A) By reducing the number of if statements

B) By increasing the number of nested levels

C) By using proper indentation and reducing unnecessary nesting

D) By using only one condition in the if statement

7. Can you use nested if-else statements with example to check multiple conditions with logical operators like AND (&&) or OR (||)?

A) No, nested if-else can only check single conditions

B) Yes, logical operators can be used within nested if-else statements to combine multiple conditions

C) Only if statements can use logical operators, not else

D) Nested if-else statements don’t support logical operators

8. When should you refactor a nested if-else statement syntax?

A) When the code gets too long and hard to read

B) When the logic becomes overly complicated with deep nesting

C) When it leads to too many syntax errors

D) All of the above

9. What is a common mistake made when using nested if-else statements in C?

A) Always putting the most probable condition at the bottom

B) Forgetting to close one or more curly braces

C) Using too few nested levels

D) Writing overly simple conditions

10. Which of the following scenarios would be best suited for a nested if-else statement example?

A) Checking if a number is prime

B) Checking if a person is eligible for voting based on multiple criteria (age, citizenship)

C) Printing all numbers in a range

D) Counting the number of vowels in a string

Understanding nested if-else statements in C is just the beginning—keep building your C programming skills with expert-led courses and hands-on learning.  

How Can upGrad Help You Master Nested If-Else Statements in C?

Now that you’ve tested your knowledge of nested if-else statements, it's time to solidify your understanding with expert-led learning. Upgrading your skills is essential, and upGrad offers comprehensive courses to help you master C programming, including working with nested conditions.

Explore nested if-else statements and other advanced topics in C programming. upGrad provides interactive learning and hands-on projects to enhance your problem-solving abilities.

Check out upGrad’s courses to deepen your expertise:

• Data Structures & Algorithms
• Learn Basic Python Programming
• JavaScript Basics from Scratch
• AI-Powered Full Stack Development Course by IIITB

You can also get personalized career counseling with upGrad to guide your career path, or visit your nearest upGrad center and start hands-on training today! 

Similar Reads:

Explore C Tutorials: From Beginner Concepts to Advanced Techniques

Array in C: Introduction, Declaration, Initialisation and More

Exploring Array of Pointers in C: A Beginner's Guide

What is C Function Call Stack: A Complete Tutorial

Binary Search in C

Constant Pointer in C: The Fundamentals and Best Practices

Find Out About Data Structures in C and How to Use Them?

FAQs 

1. How does the nested if-else statement syntax differ from a regular if-else statement?

The nested if-else statement syntax allows you to place one if-else statement inside another, enabling more complex decision-making by evaluating multiple conditions.

2. Can I use a nested if-else statement with an example to check more than two conditions?

Yes, you can check as many conditions as needed. A nested if-else statement with example can handle multiple conditions within the inner and outer blocks, providing more flexibility in logic.

3. What is the advantage of using nested if-else statement syntax over multiple separate if statements?

The nested if-else statement syntax provides a clear, structured way to handle complex decision-making, ensuring that only one condition is evaluated at a time and improving the readability of your code.

4. When should I avoid using nested if-else statements with examples in my C program?

Avoid using nested if-else statements with examples when you have too many nested levels, as it can lead to code that is difficult to read and maintain. Consider alternatives like switch statements or refactoring.

5. How do I handle edge cases effectively with nested if-else statement syntax?

Ensure that your nested if-else statement syntax accounts for all possible conditions, including boundary cases. Use proper logic to check for edge cases, such as invalid inputs or extreme values.

6. Can I break out of a nested if-else statement using a jump statement?

Yes, you can use jump statements like break or return inside a nested if-else statement to exit early, but they should be used carefully to maintain clarity in your logic.

7. How deep can I nest if-else statements in C before it becomes unreadable?

It's best to limit nesting to 2-3 levels. If you need more, consider breaking the logic into separate functions to maintain readability and avoid cluttering your code with excessive nested if-else statement syntax.

8. Can nested if-else statements with example be used for validating user input in C?

Yes, nested if-else statements with example are ideal for validating multiple user inputs, such as checking if an age is within a valid range or if a password meets the required conditions.

9. How can I improve the performance of my nested if-else statement syntax?

Optimize performance by reducing the depth of nesting and ensuring that the most likely conditions are checked first, minimizing the number of evaluations needed in the nested if-else statement.

10. Are there any situations where I should use nested if-else statements with an example instead of a switch statement?

Use nested if-else statements with examples when dealing with complex conditions that involve ranges, logical operators, or multiple criteria. A switch statement is better for evaluating one variable against multiple constant values.

11. How do I ensure my nested if-else statement syntax is maintainable?

Keep your nested if-else statement syntax simple, avoid deep nesting, and use proper indentation to make the code easy to read. Refactor complex logic into smaller, reusable functions for better maintainability.

Take a Free C Programming Quiz

Answer quick questions and assess your C programming knowledge

Start Quiz