The C if Statement: Conditions, Syntax, and Examples

The Basic Syntax

if (condition) {
    // code runs ONLY when condition is true
}

Three parts:

1. The keyword if
2. A condition in parentheses — an expression that C evaluates as true or false
3. A block in braces { } — the code that runs when the condition passes

A first real example:

#include <stdio.h>
int main() {
    int temperature;
    printf("Enter today's temperature (°C): ");
    scanf("%d", &temperature);
    if (temperature > 35) {
        printf("It's hot outside! Stay hydrated.\n");
    }
    printf("Have a nice day!\n");
    return 0;
}

Two possible runs:

Enter today's temperature (°C): 38It's hot outside! Stay hydrated.Have a nice day!

Enter today's temperature (°C): 22Have a nice day!

When the condition passes, the extra message appears. When it fails, the program skips the block like it was never there and carries on below. That skip-or-run behavior is the entire essence of if.

How C Decides "True" and "False"

Here's the detail that separates people who use if from people who understand it: C has no built-in true/false type (not in classic C, anyway). Instead, it uses numbers:

• 0 is false
• Any non-zero value is true — 1, 42, -7, 0.5, all of them

This leads to some perfectly legal, wonderfully weird code:

if (1) // always true — block always runsif (0)        // always false — block never runsif (-5)       // true! Non-zero is non-zero.if (42 - 42)  // false — the expression equals 0

Understanding this explains one of C's most famous bugs (coming up shortly), so keep it in your pocket.

(Suggested image: a simple "truth scale" graphic — "0 = FALSE" on one side, "everything else = TRUE" on the other)

Building Conditions: Relational Operators

Most conditions compare two values using relational operators:

int marks = 72;
if (marks >= 40) {
    puts("Passed!");
}
if (marks == 100) {
    puts("Perfect score!");
}
if (marks != 0) {
    puts("You wrote something, at least.");
}

⚠️ Read this twice: equality is == (double equals). A single = is assignment, and using it inside a condition creates the most infamous bug in C — we'll dissect it in the mistakes section.

Combining Conditions: Logical Operators

One comparison often isn't enough. "Age 18 or above and has an ID" needs two conditions at once. That's what logical operators do:

AND — everything must pass:

int age = 25;
int hasID = 1;
// 1 means yes
if (age >= 18 && hasID) {
    puts("Entry granted.");
}

OR — one is enough:

char day = 'S';
// S = weekend
if (day == 'S' || day == 's') {
    puts("It's the weekend!");
}

NOT — flip the result:

int loggedIn = 0;
if (!loggedIn) {
    // reads as "if NOT logged in"    puts("Please log in first.");
}

Grouping with parentheses keeps complex conditions honest:

if ((age >= 18 && hasID) || isVIP) {
    puts("Welcome in!");
}

Without the parentheses, C applies its own precedence rules (&& binds tighter than ||), which may not match what you meant. When a condition mixes && and ||, always parenthesize — future readers will thank you.

(Suggested image: three small Venn-style graphics — AND as overlap, OR as union, NOT as inversion)

The Braces Question: When Can You Skip { }?

If the block contains exactly one statement, braces are optional:

if (marks >= 40) puts("Passed!");
// works fine — one statement, no braces

But watch what happens when you add a second line:

if (marks >= 40) puts("Passed!");
puts("Congratulations!");
// NOT part of the if — ALWAYS runs!

Indentation means nothing to C. Only the first line belongs to the if; the second runs no matter what. This bug hides well because the code looks right.

The professional habit: always use braces, even for one line. It costs you two characters and eliminates an entire category of bug forever. Most company style guides mandate it for exactly this reason.

Nested if: Decisions Inside Decisions

An if can live inside another if — useful when one check only makes sense after another passes:

int age = 20;
int hasLicense = 1;
if (age >= 18) {
    if (hasLicense) {
        puts("You may drive.");
    } else {
        puts("Old enough, but get a license first!");
    }
} else {
    puts("Too young to drive.");
}

Nesting works fine to a point — but past two or three levels, code turns into a sideways arrow that's painful to read. Often you can flatten nesting with &&:

// Same logic, flatter:if (age >= 18 && hasLicense) {
puts("You may drive.");
}

Choose whichever version communicates your intent more clearly.

A Practical Example: ATM Withdrawal Check

#include <stdio.h>
int main() {
    float balance = 5000.00;
    float amount;
    printf("Enter withdrawal amount: ");
    scanf("%f", &amount);
    if (amount <= 0) {
        puts("Invalid amount.");
    }
    if (amount > balance) {
        printf("Insufficient funds. Balance: %.2f\n", balance);
    }
    if (amount > 0 && amount <= balance) {
        balance -= amount;
        printf("Withdrawal successful!\n");
        printf("Remaining balance: %.2f\n", balance);
    }
    return 0;
}

Sample Run:

Enter withdrawal amount: 1500Withdrawal successful!Remaining balance: 3500.00

Three independent checks — each guarding one rule. (In the next tutorial, if-else will show how to make these mutually exclusive, which is the more natural fit here. Stay tuned.)

The Five Famous if Mistakes

1. = instead of == (the legend)

int x = 10;
if (x = 5) {
    // ASSIGNS 5, doesn't compare!    puts("This always prints.");
}

Remember "0 is false, non-zero is true"? x = 5 assigns 5 to x, and the assignment's value is 5 — non-zero — so the condition is always true. Your program compiles, runs, and lies to you. Some programmers defensively write if (5 == x) ("Yoda conditions") so a typo becomes a compile error instead of a silent bug. Compilers with -Wall also warn about this.

2. The stray semicolon

if (marks >= 40);
// ← this semicolon ENDS the if!{
puts("Passed!");
// always runs — it's a separate block
}

That innocent ; is an empty statement. The if controls nothing, and the braces run unconditionally.

3. Skipping braces for multiple statements — covered above. Only the first statement attaches to the if.

4. Floating-point equality

float f = 0.1 + 0.2;
if (f == 0.3) {
    // FALSE! f is actually 0.30000000000000004
    puts("Never prints.");
}

Floats are approximations. Compare them with a tolerance instead:

if (f > 0.299 && f < 0.301) {
    ...
}

5. Comparing strings with ==

char name[] = "Ravi";
if (name == "Ravi") {
    // compares ADDRESSES, not text!

For strings, use strcmp() from string.h:

#include <string.h>
if (strcmp(name, "Ravi") == 0) {
    // 0 means the strings match
    puts("Hello, Ravi!");
}

(Suggested image: "5 if-Statement Mistakes" checklist graphic — matching the series style)

The Dangling else Puzzle

Quick quiz — which if does this else belong to?

if (a > 0)
if (b > 0)
puts("both positive");
else
puts("???");

The answer: an else always pairs with the nearest unmatched if — here, if (b > 0), regardless of how the indentation suggests otherwise. This "dangling else" trap has confused generations of programmers. The fix is, once again, braces:

if (a > 0) {
    if (b > 0) {
        puts("both positive");
    }
} else {
    puts("a is not positive");
    // now crystal clear
}

Final Thoughts

The if statement is programming reduced to its essence: check something, act accordingly. Everything more advanced — else if chains, switch, even loops — is built on the same true/false foundation you learned here.

Carry these lessons with you: zero is false, everything else is true; == compares while = assigns; always use braces; and never trust == with floats or strings. Nail those five, and if will serve you faithfully for the rest of your C journey.

Next up: what happens when the condition fails — the else and else if statements.