Relational Operators in C: Comparing Values and Results

The Six Relational Operators

#include <stdio.h>
int main() {
    int a = 10, b = 20;
    printf("%d\n", a == b);
    // 0 — false: 10 isn't 20
    printf("%d\n", a != b);
    // 1 — true: they differ
    printf("%d\n", a < b);
    // 1 — true
    printf("%d\n", a > b);
    // 0 — false
    printf("%d\n", a <= 10);
    // 1 — true: equal counts
    printf("%d\n", b >= 25);
    // 0 — false
    return 0;
}

What Comparisons Actually Return: The 1 and 0 System

Here's the detail that separates people whousethese operators from people whounderstandthem:

A relational expression doesn't produce "true" or "false" text. It produces the integer 1 (true) or 0 (false).

That output above — those bare1s and0s —isthe comparison result, printed raw. A comparison is just an expression with a numeric value, which means you can store it, return it, and calculate with it:

int isAdult =(age >= 18);
// stores 1 or 0
int bothPassed =(s1 >= 40) +(s2 >= 40);
// adds the results: 0, 1, or 2!

That second line looks like a party trick, but it's real C: each comparison yields 1 or 0, and adding them counts how many conditions passed. (You'll write clearer code with&&, but understandingwhythis works means you truly get the 1/0 system.)

This numeric nature is exactly what makesifstatements work —ifdoesn't need "true", it needsnon-zero:

if (marks >= 40) {
    // marks >= 40 becomes 1 (or 0)...
    printf("Pass\n");
    // ...and if () runs on anything non-zero
}

Trap #1: The = vs == Disaster

The single most infamous typo in C:

int marks = 30;
if (marks = 40) {
    // 😱 = ASSIGNS 40 — not a comparison!
    printf("Passed!\n");
    // always runs — and marks is now 40!
}

Why does this compileandrun? Because assignment is an expression that evaluates to the assigned value.marks = 40sets marks to 40 and evaluates to40— non-zero — soifseestrue. The bug compiles silently, runs happily, and lies to you logically.

if (marks == 40) // ✅ == COMPARES — this is what you meant

The defensive habit:some programmers writeif (40 == marks)— constant on the left. Thenif (40 = marks)becomes a compileerrorinstead of a silent bug. It's called a Yoda condition, and while modern compilers warn about assignment-in-if, the habit has saved countless programmers.

Trap #2: Chained Comparisons Don't Work

Coming from math class, thislooksperfectly reasonable:

int age = 15;
// "check if age is between 18 and 60" — the WRONG way
if (18 <= age <= 60) {
    // 😱 compiles fine, works WRONG
    printf("In range!\n");
    // runs?! even though 15 is out of range!
}

Why does it misbehave? C reads left to right:

1. 18 <= 15→ false →0
2. 0 <= 60→ true →1✅ (0 is definitely ≤ 60!)

The comparison collapses into a 1-or-0 before the next comparison happens. The math-class chain simply doesn't exist in C. The correct version joins two separate comparisons with&&:

if (age >= 18 && age <= 60) {
    // ✅ both sides checked independently
    printf("In range!\n");
}

Every "between" check in C is two comparisons glued with&&.

Comparing Characters: It Works (Here's Why)

Because everycharis secretly an ASCII number, characters compare directly:

char grade = 'B';
if (grade == 'A') {
    /* not this time */
}
if (grade >= 'A' && grade <= 'Z') {
    printf("Uppercase letter\n");
    // runs — range check on characters!
}
printf("%d\n", 'a' > 'A');
// 1 — 'a' (97) beats 'A' (65)

'a' > 'A'is true because lowercase letters have higher ASCII codes (97 > 65). This numeric nature is what makes alphabet loops, case conversion, and character classification possible in C.

The Float Warning: Never Compare Decimals With ==

One final trap — this one bites even experienced programmers:

double x = 0.1 + 0.2;
if (x == 0.3) {
    printf("Equal\n");
} else {
    printf("NOT equal — x is actually %.20f\n", x);
    // x is 0.30000000000000004441 — NOT equal prints!
}

Floating-point numbers are approximations.0.1 + 0.2doesn't equal0.3exactly — it equals something microscopically off, and==demandsexactness. The professional fix compares within a small tolerance:

#include <math.h> // for fabs()
if (fabs(x - 0.3) < 0.000001) {
    // "close enough"
    printf("Equal (within tolerance)\n");
}

Rule:compare floats for equality using a tolerance, never==.

A Complete Working Example: Grade Evaluator

#include <stdio.h>
int main() {
    int marks = 85;
    printf("Marks: %d\n", marks);
    if (marks >= 90) {
        printf("Grade: A+ (Outstanding)\n");
    } else if (marks >= 75) {
        printf("Grade: A (Excellent)\n");
        // this one runs
    } else if (marks >= 60) {
        printf("Grade: B (Good)\n");
    } else if (marks >= 40) {
        printf("Grade: C (Pass)\n");
    } else {
        printf("Grade: F (Fail)\n");
    }
    // relational results as numbers
    printf("Passed (1=yes, 0=no): %d\n", marks >= 40);
    printf("Distinction? %d\n", marks >= 90);
    return 0;
}

Output:

Marks: 85
Grade: A(Excellent)
Passed(1=yes, 0=no): 1
Distinction? 0

Every branch in that ladder is powered by a relational operator doing its quiet 1-or-0 job.