C Operators

Basic Arithmetic Operators

#include <stdio.h>

int main() {
    int a = 17, b = 5;
    
    printf("a = %d, b = %d\n\n", a, b);
    
    printf("Addition:       a + b = %d\n", a + b);    // 22
    printf("Subtraction:    a - b = %d\n", a - b);    // 12
    printf("Multiplication: a * b = %d\n", a * b);    // 85
    printf("Division:       a / b = %d\n", a / b);    // 3 (integer division)
    printf("Modulus:        a %% b = %d\n", a % b);   // 2 (remainder)
    
    return 0;
}

Integer vs Floating-Point Division

A common source of bugs! Division behaves differently depending on the operand types:

int result = 7 / 2;    // result = 3, NOT 3.5!
int result2 = 1 / 2;   // result2 = 0, NOT 0.5!

float result = 7.0 / 2;     // result = 3.5
float result2 = 7 / 2.0;    // result2 = 3.5
float result3 = (float)7/2; // result3 = 3.5

Increment (++) and Decrement (--)

These unary operators increase or decrease a value by 1. They come in two forms:

int x = 5;
int y = ++x;  // x becomes 6 FIRST, then y = 6
// x = 6, y = 6

int x = 5;
int y = x++;  // y = 5 (old value), THEN x becomes 6
// x = 6, y = 5

#include <stdio.h>

int main() {
    int a = 5, b = 5;
    
    printf("Initial: a = %d, b = %d\n\n", a, b);
    
    // Pre-increment: increment first, then use
    printf("++a = %d\n", ++a);  // Prints 6, a is now 6
    printf("After ++a: a = %d\n\n", a);
    
    // Post-increment: use first, then increment
    printf("b++ = %d\n", b++);  // Prints 5, b becomes 6 after
    printf("After b++: b = %d\n\n", b);
    
    // Same logic applies to decrement (--)
    int c = 10;
    printf("--c = %d\n", --c);  // Prints 9
    printf("c-- = %d\n", c--);  // Prints 9, c becomes 8
    printf("Final c = %d\n", c); // Prints 8
    
    return 0;
}

Practical Uses of Modulus (%)

The modulus operator has many practical applications:

#include <stdio.h>

int main() {
    // 1. Check if a number is even or odd
    int num = 17;
    if (num % 2 == 0) {
        printf("%d is even\n", num);
    } else {
        printf("%d is odd\n", num);  // This prints
    }
    
    // 2. Extract digits from a number
    int number = 1234;
    int lastDigit = number % 10;     // 4
    int lastTwo = number % 100;      // 34
    printf("Last digit of %d: %d\n", number, lastDigit);
    
    // 3. Wrap around (circular behavior)
    // Useful for arrays, clocks, games
    int hours = 25 % 24;  // 1 (25 hours wraps to 1:00)
    int index = 7 % 5;    // 2 (index wraps in array of size 5)
    printf("25 hours = %d o'clock\n", hours);
    
    // 4. Check divisibility
    int year = 2024;
    if (year % 4 == 0) {
        printf("%d is divisible by 4\n", year);
    }
    
    return 0;
}

Relational Operators Table

#include <stdio.h>

int main() {
    int a = 10, b = 20, c = 10;
    
    printf("a = %d, b = %d, c = %d\n\n", a, b, c);
    
    printf("a == b: %d\n", a == b);  // 0 (false)
    printf("a == c: %d\n", a == c);  // 1 (true)
    printf("a != b: %d\n", a != b);  // 1 (true)
    printf("a > b:  %d\n", a > b);   // 0 (false)
    printf("a < b:  %d\n", a < b);   // 1 (true)
    printf("a >= c: %d\n", a >= c);  // 1 (true)
    printf("b <= a: %d\n", b <= a);  // 0 (false)
    
    return 0;
}

Using Relational Operators in Conditions

Let's see how relational operators power decision-making in real programs:

Simple Condition Check

int age = 18;

// Simple condition - checking a single requirement
if (age >= 18) {
    printf("You are an adult.\n");
}

Checking Multiple Ranges (Grade Calculator)

int score = 85;

// Checking ranges with else-if chain
if (score >= 90) {
    printf("Grade: A\n");
} else if (score >= 80) {
    printf("Grade: B\n");  // This prints (85 >= 80)
} else if (score >= 70) {
    printf("Grade: C\n");
} else {
    printf("Grade: F\n");
}

Checking Exact Values and Boundaries

float temperature = 37.5;

// Checking equality and greater-than
if (temperature == 37.0) {
    printf("Normal temperature\n");
} else if (temperature > 37.0) {
    printf("Slight fever\n");  // This prints (37.5 > 37.0)
}

Complete Program Structure

#include <stdio.h>

int main() {
    int age = 18;
    int score = 85;
    float temperature = 37.5;
    
    // Your conditional logic goes here...
    
    return 0;
}

Common Mistake: = vs ==

int x = 5;
if (x = 10) {  // WRONG! This assigns 10 to x
    // Always executes because x=10 evaluates to 10 (true)
    printf("This always runs!\n");
}

int x = 5;
if (x == 10) {  // Correct! Compares x to 10
    printf("x is 10\n");
} else {
    printf("x is not 10\n");  // This prints
}

Logical Operators

Truth Tables

Practical Examples

Let's see logical operators in action with real-world scenarios:

AND (&&) - All Conditions Must Be True

int age = 25;
int hasLicense = 1;  // 1 = true
int isSober = 1;

// All three conditions must be true to drive
if (age >= 18 && hasLicense && isSober) {
    printf("You can drive!\n");  // This prints
}

OR (||) - At Least One Must Be True

int isWeekend = 0;   // 0 = false (it's a weekday)
int isHoliday = 0;

// Either weekend OR holiday means day off
if (isWeekend || isHoliday) {
    printf("You have a day off!\n");
} else {
    printf("It's a work day\n");  // This prints
}

NOT (!) - Inverts the Condition

int isRaining = 0;  // 0 = false (not raining)

// NOT raining means good weather
if (!isRaining) {
    printf("Great weather for outdoor activities!\n");  // This prints
}

Combining Multiple Operators

int temperature = 25;
int isRaining = 0;

// Good weather: temperature between 20-30 AND not raining
if ((temperature > 20 && temperature < 30) && !isRaining) {
    printf("Perfect weather for a walk!\n");  // This prints
}

Range Checking Pattern

int score = 85;

// Check if score is in the B grade range (80-89)
if (score >= 80 && score < 90) {
    printf("Grade: B\n");  // This prints
}

// Common pattern for multiple ranges
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");

Short-Circuit Evaluation

C uses "short-circuit" evaluation for logical operators, which can affect performance and behavior:

int x = 0;
// Second condition never checked
if (x != 0 && 10/x > 2) {
    // Safe! No division by zero
}

int valid = 1;
// Second condition never checked
if (valid || expensiveCheck()) {
    // expensiveCheck() not called
}

Bitwise Operators

Bitwise Operations in Action

Let's see each bitwise operator working on binary numbers step by step:

Setting Up Binary Values

unsigned int a = 5;   // Binary: 0101
unsigned int b = 3;   // Binary: 0011

printf("a = %u (binary: 0101)\n", a);
printf("b = %u (binary: 0011)\n\n", b);

Bitwise AND (&) - Both Bits Must Be 1

// Bitwise AND: both bits must be 1
printf("a & b  = %u\n", a & b);   // 0101 & 0011 = 0001 = 1

//   0101 (5)
// & 0011 (3)
// --------
//   0001 (1)

Bitwise OR (|) - Either Bit Can Be 1

// Bitwise OR: at least one bit must be 1
printf("a | b  = %u\n", a | b);   // 0101 | 0011 = 0111 = 7

//   0101 (5)
// | 0011 (3)
// --------
//   0111 (7)

Bitwise XOR (^) - Bits Must Be Different

// Bitwise XOR: bits must be different
printf("a ^ b  = %u\n", a ^ b);   // 0101 ^ 0011 = 0110 = 6

//   0101 (5)
// ^ 0011 (3)
// --------
//   0110 (6)

Bitwise NOT (~) - Flip All Bits

// Bitwise NOT (complement)
printf("~a     = %d\n", ~a);      // Inverts all bits = -6

// ~0000...0101 = 1111...1010 = -6 (in 2's complement)

Left Shift (<<) - Multiply by Powers of 2

// Left shift (multiply by 2^n)
printf("a << 1 = %u\n", a << 1);  // 0101 << 1 = 1010 = 10
printf("a << 2 = %u\n", a << 2);  // 0101 << 2 = 10100 = 20

// 0101 << 1 = 1010  (5 * 2 = 10)
// 0101 << 2 = 10100 (5 * 4 = 20)

Right Shift (>>) - Divide by Powers of 2

// Right shift (divide by 2^n)
printf("a >> 1 = %u\n", a >> 1);  // 0101 >> 1 = 0010 = 2

// 0101 >> 1 = 0010 (5 / 2 = 2, integer division)

Practical Applications

#include <stdio.h>

int main() {
    // 1. Check if a number is even or odd (faster than modulus)
    int num = 7;
    if (num & 1) {
        printf("%d is odd\n", num);   // Last bit is 1 = odd
    } else {
        printf("%d is even\n", num);  // Last bit is 0 = even
    }
    
    // 2. Multiply/divide by powers of 2 (very fast)
    int x = 5;
    printf("%d * 4 = %d\n", x, x << 2);   // Left shift by 2 = multiply by 4
    printf("%d / 2 = %d\n", x, x >> 1);   // Right shift by 1 = divide by 2
    
    // 3. Set, clear, and toggle specific bits (flags)
    unsigned char flags = 0;          // 00000000
    
    // Set bit 2 (turn ON)
    flags = flags | (1 << 2);         // 00000100
    printf("After setting bit 2: %d\n", flags);
    
    // Clear bit 2 (turn OFF)
    flags = flags & ~(1 << 2);        // 00000000
    printf("After clearing bit 2: %d\n", flags);
    
    // Toggle bit 3 (flip)
    flags = flags ^ (1 << 3);         // 00001000
    printf("After toggling bit 3: %d\n", flags);
    
    // 4. Swap two numbers without temporary variable
    int p = 10, q = 20;
    printf("Before swap: p=%d, q=%d\n", p, q);
    p = p ^ q;
    q = p ^ q;
    p = p ^ q;
    printf("After swap:  p=%d, q=%d\n", p, q);
    
    return 0;
}

Assignment Operators

Examples

#include <stdio.h>

int main() {
    int x = 10;
    printf("Initial x = %d\n\n", x);
    
    // Arithmetic compound assignments
    x += 5;   // x = x + 5 = 15
    printf("After x += 5:  x = %d\n", x);
    
    x -= 3;   // x = x - 3 = 12
    printf("After x -= 3:  x = %d\n", x);
    
    x *= 2;   // x = x * 2 = 24
    printf("After x *= 2:  x = %d\n", x);
    
    x /= 4;   // x = x / 4 = 6
    printf("After x /= 4:  x = %d\n", x);
    
    x %= 4;   // x = x % 4 = 2
    printf("After x %%= 4: x = %d\n\n", x);
    
    // Bitwise compound assignments
    unsigned int flags = 0b00001111;  // 15 in decimal
    printf("Initial flags = %u\n", flags);
    
    flags &= 0b00000011;  // Keep only last 2 bits
    printf("After flags &= 0b00000011: flags = %u\n", flags);  // 3
    
    flags |= 0b00010000;  // Set bit 4
    printf("After flags |= 0b00010000: flags = %u\n", flags);  // 19
    
    // Shift assignments
    int num = 4;
    num <<= 2;  // Multiply by 4
    printf("4 <<= 2 = %d\n", num);  // 16
    
    num >>= 1;  // Divide by 2
    printf("16 >>= 1 = %d\n", num);  // 8
    
    return 0;
}

Operator Precedence (High to Low)

Precedence Examples

#include <stdio.h>

int main() {
    // Example 1: Arithmetic precedence
    int result1 = 2 + 3 * 4;        // 2 + 12 = 14 (not 20)
    int result2 = (2 + 3) * 4;      // 5 * 4 = 20 (parentheses override)
    printf("2 + 3 * 4 = %d\n", result1);
    printf("(2 + 3) * 4 = %d\n\n", result2);
    
    // Example 2: Relational vs logical
    int a = 5, b = 3, c = 8;
    // Without parentheses (works due to precedence)
    int test1 = a > b && b < c;     // (a > b) && (b < c) = 1 && 1 = 1
    printf("a > b && b < c = %d\n", test1);
    
    // Example 3: Assignment has low precedence
    int x = 5;
    int y = x + 3;                  // x + 3 is evaluated first, then assigned
    printf("y = x + 3 = %d\n\n", y);
    
    // Example 4: Be careful with bitwise vs comparison
    int n = 5;
    // WRONG: & has lower precedence than ==
    // if (n & 1 == 0)  // Evaluates as n & (1 == 0) = n & 0 = 0
    
    // CORRECT: Use parentheses
    if ((n & 1) == 0) {
        printf("%d is even\n", n);
    } else {
        printf("%d is odd\n", n);   // This prints
    }
    
    // Example 5: Chained assignment (right to left)
    int p, q, r;
    p = q = r = 10;                 // r=10, then q=10, then p=10
    printf("p=%d, q=%d, r=%d\n", p, q, r);
    
    return 0;
}