C nested if Statement

What You’ll Learn

A nested if places one condition inside another. The inner test runs only when the outer test already passed—perfect for step-by-step checks like “is the user an adult?” then “did they pass the exam?” This tutorial builds on if, if-else, and else if with clear syntax, five examples, and tips to keep nested code readable.

Definition and Usage

A nested if statement is an if written inside the body of another if or else block. The inner condition is evaluated only when the outer condition is true (or when execution enters that else branch).

Use nesting when a second decision depends on the first. Admission checks, login validation, and “positive then even/odd” splits are classic patterns. When several outcomes sit at the same level, an else if ladder is often clearer.

📝 Syntax

General form of a nested if inside an outer if:

if (outer_condition) {
    // outer body runs when outer_condition is true
    if (inner_condition) {
        // runs only when BOTH outer and inner are true
    }
}

Nested if-else

You can nest if-else inside if or else blocks:

if (condition1) {
    if (condition2) {
        // both true
    } else {
        // condition1 true, condition2 false
    }
} else {
    // condition1 false
}

Evaluation order

• Outer if — tested first.
• Inner if — tested only if the outer block is entered and its condition was true.
• Both must pass — for the innermost body to run when using nested if without else between them.
• Braces — use { } on every branch to avoid dangling else bugs.

Compile

gcc program.c -std=c11 -o program

Examples Gallery

Compile with gcc example.c -std=c11 -o example. Each program shows a different nested if pattern.

#include <stdio.h>

int main(void) {
    int num = 10;

    if (num > 0) {
        printf("Number is positive\n");

        if (num % 2 == 0) {
            printf("Number is even\n");
        }
    }

    return 0;
}

Number is positive
Number is even

#include <stdio.h>

int main(void) {
    int age = 20;
    int grade = 85;

    if (age >= 18) {
        if (grade >= 60) {
            printf("Eligible for admission\n");
        } else {
            printf("Not eligible due to low grade\n");
        }
    } else {
        printf("Not eligible due to age\n");
    }

    return 0;
}

Eligible for admission

#include <stdio.h>

int main(void) {
    int number = -5;

    if (number >= 0) {
        if (number == 0) {
            printf("Number is zero\n");
        } else {
            printf("Number is positive\n");
        }
    } else {
        printf("Number is negative\n");
    }

    return 0;
}

Number is negative

#include <stdio.h>

int main(void) {
    int num = 10;

    if (num > 0 && num % 2 == 0) {
        printf("Number is positive and even\n");
    }

    return 0;
}

Number is positive and even

#include <stdio.h>

int main(void) {
    double balance = 500.0;
    double amount = 200.0;

    if (balance > 0) {
        if (amount <= balance) {
            balance -= amount;
            printf("Withdrawal OK. New balance: %.2f\n", balance);
        } else {
            printf("Insufficient funds for %.2f\n", amount);
        }
    } else {
        printf("Account has no funds\n");
    }

    return 0;
}

Withdrawal OK. New balance: 300.00

🚀 Common Use Cases

• Eligibility — age, then score, then documents verified.
• Authentication — user found, then password matches.
• Input validation — in range, then format correct.
• Classification — positive, then even/odd or divisible by N.
• Resource guards — file open, then read succeeds.
• Business rules — discount applies, then cart total qualifies.

📝 Notes

• Indent each nesting level so structure is visible at a glance.
• Always use braces—they prevent dangling else mistakes.
• Two simple AND conditions can often be one line with &&.
• Same-level exclusive outcomes belong in an else if ladder, not deep nesting.
• Extract logic into functions when nesting exceeds two or three levels.
• Comments on non-obvious branches help future readers (including you).

⚡ Optimization

Put the cheapest or most likely-to-fail outer condition first so inner tests are skipped when possible. Combining independent checks with && lets the compiler short-circuit: if the left side is false, the right side is not evaluated. For very deep trees, a switch or lookup table may outperform a long nested chain—but clarity matters more than micro-optimization at beginner scale.

💡 Best Practices