Relational & Logical Operators

#include <stdio.h>

int main(void) {
    int a = 10, b = 20;
    
    /* Equal to */
    printf("%d == %d is %d\n", a, b, a == b);  // 0 (false)
    printf("%d == %d is %d\n", a, a, a == a);  // 1 (true)
    
    /* Not equal to */
    printf("%d != %d is %d\n", a, b, a != b);  // 1 (true)
    printf("%d != %d is %d\n", a, a, a != a);  // 0 (false)
    
    /* Greater than */
    printf("%d &gt; %d is %d\n", b, a, b &gt; a);    // 1 (true)
    printf("%d &gt; %d is %d\n", a, b, a &gt; b);    // 0 (false)
    
    /* Less than */
    printf("%d < %d is %d\n", a, b, a < b);    // 1 (true)
    printf("%d < %d is %d\n", b, a, b < a);    // 0 (false)
    
    /* Greater than or equal to */
    printf("%d >= %d is %d\n", a, a, a >= a);  // 1 (true)
    printf("%d >= %d is %d\n", b, a, b >= a);  // 1 (true)
    printf("%d >= %d is %d\n", a, b, a >= b);  // 0 (false)
    
    /* Less than or equal to */
    printf("%d <= %d is %d\n", a, b, a <= b);  // 1 (true)
    printf("%d <= %d is %d\n", a, a, a <= a);  // 1 (true)
    printf("%d <= %d is %d\n", b, a, b <= a);  // 0 (false)
    
    return 0;
}

/* if statements */
int age = 18;

if (age >= 18) {
    printf("You are an adult\n");
}

if (age < 18) {
    printf("You are a minor\n");
}

/* if-else */
int score = 85;

if (score >= 90) {
    printf("Grade: A\n");
} else if (score >= 80) {
    printf("Grade: B\n");
} else if (score >= 70) {
    printf("Grade: C\n");
} else {
    printf("Grade: F\n");
}

/* while loops */
int count = 0;
while (count < 5) {
    printf("%d ", count);
    count++;
}
printf("\n");  // Output: 0 1 2 3 4

/* for loops */
for (int i = 0; i < 10; i++) {
    printf("%d ", i);
}
printf("\n");

/* Common mistake: = vs == */
int x = 5;
if (x = 10) {  // OOPS: Assignment, not comparison!
    printf("This always runs!\n");  // x assigned 10, which is true
}

/* Correct comparison */
if (x == 10) {  // Comparison
    printf("x equals 10\n");
}

/* Logical AND - both must be true */
int age = 25;
int has_license = 1;

if (age >= 18 && has_license) {
    printf("You can drive\n");
}

/* Truth table for AND */
printf("0 && 0 = %d\n", 0 && 0);  // 0 (false)
printf("0 && 1 = %d\n", 0 && 1);  // 0 (false)
printf("1 && 0 = %d\n", 1 && 0);  // 0 (false)
printf("1 && 1 = %d\n", 1 && 1);  // 1 (true)

/* Short-circuit evaluation */
int x = 0;
int y = 10;

if (x != 0 && y / x > 2) {  // Safe: second part not evaluated when x==0
    printf("This won't crash\n");
}

/* Multiple conditions */
int temp = 72;
int humidity = 50;
int pressure = 1013;

if (temp &gt; 65 && temp < 85 && humidity < 70 && pressure &gt; 1000) {
    printf("Perfect weather conditions\n");
}

/* Logical OR - at least one must be true */
char grade = 'A';

if (grade == 'A' || grade == 'B') {
    printf("Good grade!\n");
}

/* Truth table for OR */
printf("0 || 0 = %d\n", 0 || 0);  // 0 (false)
printf("0 || 1 = %d\n", 0 || 1);  // 1 (true)
printf("1 || 0 = %d\n", 1 || 0);  // 1 (true)
printf("1 || 1 = %d\n", 1 || 1);  // 1 (true)

/* Short-circuit evaluation */
int found = 1;
int search_result = 0;

if (found || (search_result = expensive_search()) != 0) {
    printf("Found!\n");  // expensive_search() not called if found==1
}

/* Multiple conditions */
char day = 'S';

if (day == 'S' || day == 'U') {  // Saturday or Sunday
    printf("It's the weekend!\n");
}

/* Logical NOT - inverts boolean value */
int is_raining = 0;

if (!is_raining) {
    printf("No umbrella needed\n");
}

/* Truth table for NOT */
printf("!0 = %d\n", !0);      // 1 (true)
printf("!1 = %d\n", !1);      // 0 (false)
printf("!5 = %d\n", !5);      // 0 (false, any non-zero is true)
printf("!-3 = %d\n", !-3);    // 0 (false, negative numbers are true)

/* Double negation */
printf("!!0 = %d\n", !!0);    // 0 (false)
printf("!!5 = %d\n", !!5);    // 1 (true, converts non-zero to 1)

/* Negating comparisons */
int x = 10;

if (!(x &gt; 20)) {  // Same as: x <= 20
    printf("x is not greater than 20\n");
}

/* Clearer to write directly */
if (x <= 20) {
    printf("x is 20 or less\n");
}

/* NOT with other operators */
int is_valid = 1;
if (!is_valid) {
    printf("Invalid input\n");
} else {
    printf("Valid input\n");
}

/* Complex conditions */
int age = 25;
int income = 50000;
int credit_score = 700;

/* Loan approval logic */
if ((age >= 18 && age <= 65) && (income >= 30000 || credit_score >= 650)) {
    printf("Loan approved\n");
} else {
    printf("Loan denied\n");
}

/* De Morgan's Laws */
int a = 1, b = 0;

/* NOT (A AND B) = (NOT A) OR (NOT B) */
printf("!(a && b) = %d\n", !(a && b));      // 1
printf("(!a || !b) = %d\n", (!a || !b));    // 1 (same result)

/* NOT (A OR B) = (NOT A) AND (NOT B) */
printf("!(a || b) = %d\n", !(a || b));      // 0
printf("(!a && !b) = %d\n", (!a && !b));    // 0 (same result)

/* Range checking */
int temperature = 72;
if (temperature >= 65 && temperature <= 75) {
    printf("Comfortable temperature\n");
}

/* Exclusive OR (XOR) - true if exactly one is true */
int x = 1, y = 0;
if ((x && !y) || (!x && y)) {  // Manual XOR
    printf("Exactly one is true\n");
}

/* Using bitwise XOR for boolean (works but less clear) */
if (!!(x ^ y)) {  // Convert bitwise result to boolean
    printf("Exactly one is true\n");
}

/* Multiple conditions with precedence */
int has_ticket = 1;
int has_id = 1;
int age_check = 1;
int banned = 0;

// Precedence: ! then && then ||
if (has_ticket && has_id && (age_check || !banned)) {
    printf("Entry allowed\n");
}

/* More readable with explicit parentheses */
if (has_ticket && has_id && (age_check || (!banned))) {
    printf("Entry allowed\n");
}

/* Safe division using short-circuit */
int numerator = 10;
int denominator = 0;

if (denominator != 0 && numerator / denominator > 2) {
    printf("Quotient is large\n");
}
// Second condition not evaluated when denominator==0 (safe!)

/* Pointer safety check */
int *ptr = NULL;
if (ptr != NULL && *ptr > 0) {
    printf("Positive value\n");
}
// *ptr not dereferenced when ptr is NULL (safe!)

/* Array bounds checking */
int arr[] = {1, 2, 3, 4, 5};
int size = 5;
int index = 10;

if (index >= 0 && index < size && arr[index] &gt; 0) {
    printf("Valid positive element\n");
}
// arr[index] not accessed if index out of bounds (safe!)

/* Performance optimization with short-circuit */
int expensive_check(void) {
    printf("Expensive operation running...\n");
    return 1;
}

int quick_result = 0;
if (quick_result || expensive_check()) {
    printf("Condition met\n");
}
// expensive_check() not called if quick_result is true

/* Side effect gotcha */
int counter = 0;
int condition1 = 1;

if (condition1 || (counter++ &gt; 0)) {
    printf("Condition met\n");
}
printf("Counter: %d\n", counter);  // Still 0! counter++ not executed

/* Don't rely on side effects */
// Bad:
if (condition1 || (counter++ &gt; 0)) {"{ }"}

/* Good: Separate the side effect */
counter++;
if (condition1 || (counter &gt; 0)) {"{ }"}

/* Pitfall 1: Assignment vs Comparison */
int x = 5;

// Wrong:
if (x = 10) {  // Assignment! Always true (10 is non-zero)
    printf("Always runs\n");
}

// Correct:
if (x == 10) {  // Comparison
    printf("x equals 10\n");
}

/* Pitfall 2: Comparing floating-point numbers */
double a = 0.1 + 0.2;
double b = 0.3;

if (a == b) {  // May be false due to rounding!
    printf("Equal\n");
}

// Better: Use epsilon comparison
#include <math.h>
#define EPSILON 0.00001

if (fabs(a - b) < EPSILON) {
    printf("Approximately equal\n");
}

/* Pitfall 3: Chaining comparisons */
int age = 25;

// Wrong (doesn't work like math notation):
if (18 <= age <= 65) {  // Parsed as: (18 <= age) <= 65
    // (18 <= 25) is 1 (true), then (1 <= 65) is true
    // This is ALWAYS true!
}

// Correct:
if (age >= 18 && age <= 65) {
    printf("Valid age range\n");
}

/* Pitfall 4: Operator precedence confusion */
int a = 1, b = 0, c = 1;

// Ambiguous:
if (a || b && c) {  // What executes?
    // Answer: && has higher precedence than ||
    // Evaluated as: a || (b && c)
}

// Clear:
if (a || (b && c)) {
    printf("Clear intention\n");
}

/* Best Practices */

// 1. Use parentheses for clarity
if ((x &gt; 0) && (y &gt; 0)) {  // Very clear
    printf("Both positive\n");
}

// 2. Keep conditions simple
// Bad:
if ((a &gt; 5 && b < 10) || (c == 0 && d != 5) || (e >= 20 && f <= 30)) {"{ }"}

// Good: Break into named variables
int condition1 = (a &gt; 5 && b < 10);
int condition2 = (c == 0 && d != 5);
int condition3 = (e >= 20 && f <= 30);
if (condition1 || condition2 || condition3) {"{ }"}

// 3. Put constants on left (Yoda conditions) to catch mistakes
if (10 == x) {  // If you write = instead of ==, compiler error!
    printf("x is 10\n");
}
// if (10 = x) would be a compile error

// 4. Avoid complex negations
// Bad:
if (!(x &gt; 10 && y < 5)) {"{ }"}

// Better (De Morgan's):
if (x <= 10 || y >= 5) {"{ }"}