➕ 6. Operators

6.1 What Is an Operator?

Consider this statement:

int total = 10 + 20;

Here 10 and 20 are the operands, and + is the operator. The operator tells C to add the two operands. The result, 30, is then stored in total.

6.2 Why Are Operators Important?

A C program cannot do useful work with variables alone. Operators allow a program to calculate, compare, decide, repeat, update, and manipulate data. For example:

int marks = 75;
int pass = marks >= 40;

int salary = 30000;
salary += 5000;

int age = 22;
if (age >= 18 && age <= 60)
    printf("Eligible");

The first expression compares marks, the second updates salary, and the third combines two conditions. These are all built from operators.

6.3 Operators Based on Number of Operands

One useful way to understand operators is to count how many operands they work with. This is called their arity.

6.4 Arithmetic Operators

Arithmetic operators perform numerical calculations. The five basic arithmetic operators are:

Simple Example

#include <stdio.h>

int main(void)
{
    int a = 20;
    int b = 6;

    printf("Addition       = %d\n", a + b);
    printf("Subtraction    = %d\n", a - b);
    printf("Multiplication = %d\n", a * b);
    printf("Division       = %d\n", a / b);
    printf("Remainder      = %d\n", a % b);

    return 0;
}

Output:

Addition       = 26
Subtraction    = 14
Multiplication = 120
Division       = 3
Remainder      = 2

How Does / Work With Integers?

This is one of the most important points for beginners. When both operands are integers, C performs integer division. The fractional part is not stored in the integer result.

printf("%d\n", 7 / 2);     /* 3 */
printf("%.1f\n", 7.0 / 2); /* 3.5 */

In the first expression both operands are integers, so the result is an integer. In the second expression, 7.0 is a floating-point value, so floating- point division is performed.

What Does % Really Mean?

The modulus or remainder operator gives the remainder left after integer division. It is extremely useful for checking even/odd numbers, extracting digits, and solving cyclic problems.

int n = 27;

printf("%d\n", n % 10); /* last digit = 7 */
printf("%d\n", n % 2);  /* 1 means odd */

6.5 Relational Operators — Comparing Values

Relational operators ask a question such as “Is a greater than b?” The result of a comparison in C is an int value: 1 for true and 0 for false.

int age = 20;

printf("%d\n", age >= 18); /* 1 */
printf("%d\n", age < 18);  /* 0 */

int x = 10;       /* assignment */

if (x == 10)      /* comparison */
{
    printf("x is 10");
}

6.6 Logical Operators — Combining Conditions

Logical operators are mainly used when a program has more than one condition. C treats 0 as false and any nonzero value as true when a scalar value is used as a condition.

Logical AND &&

int age = 25;

if (age >= 18 && age <= 60)
{
    printf("Age is in the required range");
}

Both conditions must be true:

age >= 18     → true
age <= 60     → true
                  ↓
             true && true
                  ↓
                true

Logical OR ||

int day = 6;

if (day == 6 || day == 7)
{
    printf("Weekend");
}

Only one condition needs to be true for the complete OR expression to be true.

Logical NOT !

int loggedIn = 0;

if (!loggedIn)
{
    printf("Please log in");
}

Because loggedIn is zero, it represents false. Applying ! changes false to true.

6.7 Truth Table for Logical Operators

For NOT:

6.8 Short-Circuit Evaluation

Short-circuit evaluation is one of the most useful behaviors of logical operators. With &&, C evaluates the right side only when the left side is true. With ||, C evaluates the right side only when the left side is false.

if (x != 0 && 100 / x > 5)
{
    printf("Condition satisfied");
}

Suppose x is 0. The first condition x != 0 is false. Therefore C does not evaluate 100 / x. This prevents a division-by-zero operation.

6.9 Assignment Operator =

The assignment operator stores a value in a modifiable object.

int marks;

marks = 85;

Think of the statement as:

marks
  ↑
85 is stored here

The expression on the right is evaluated first. The resulting value is then converted to the type of the object on the left and stored there.

int x;

x = 10 + 5;

printf("%d", x); /* 15 */

Assignment is different from comparison:

x = 5;   /* put 5 into x */
x == 5;   /* ask whether x is equal to 5 */

6.10 Compound Assignment Operators

When a program needs to update an existing value, compound assignment operators make the code shorter and clearer.

int score = 50;

score += 10;  /* 60 */
score -= 5;   /* 55 */
score *= 2;   /* 110 */
score /= 10;  /* 11 */

printf("%d", score);

6.11 Increment and Decrement Operators

The increment operator ++ increases a value by one. The decrement operator -- decreases a value by one.

int count = 5;

count++;
printf("%d\n", count); /* 6 */

count--;
printf("%d\n", count); /* 5 */

There are two forms: prefix and postfix.

int a = 5;

int p = ++a;
/* a = 6, p = 6 */

a = 5;

int q = a++;
/* q = 5, a = 6 */

6.12 Avoid Tricky Increment Expressions

Beginners often see expressions such as:

printf("%d %d", i++, ++i);

Do not use such expressions in normal programs. When an object is modified more than once in an expression without the sequencing required by the C language, the behavior can be undefined. Even in cases that have defined behavior, such expressions are difficult for humans to read.

Prefer simple statements:

printf("%d\n", i);
i++;
printf("%d\n", i);

6.13 Conditional Operator ? :

The conditional operator is C's only ternary operator. It is useful when a program needs to choose between two expressions based on a condition.

int a = 25;
int b = 40;

int max = (a > b) ? a : b;

printf("Maximum = %d", max);

Read it as:

condition ? value_if_true : value_if_false

For the example:

(a > b) ? a : b
   ↓
Is a greater than b?
   ↓
No
   ↓
Choose b
   ↓
max = 40

Only the selected second or third operand is evaluated. This makes the conditional operator useful for compact choices, but a normal if/else statement is usually clearer when the logic becomes large.

6.14 Bitwise Operators — Working With Individual Bits

5 = 0101

5 = 0101
3 = 0011

Bitwise AND & — Keep Only Common 1 Bits

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

Bitwise OR | — Combine 1 Bits

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

Bitwise XOR ^ — Detect Differences

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

Bitwise NOT ~ — Flip Every Bit

0 → 1
1 → 0

5       = 00000101
~5      = 11111010

Why Does ~5 Become -6?

5 = 00000000 00000000 00000000 00000101

~5 = 11111111 11111111 11111111 11111010

11111111 11111111 11111111 11111010   original pattern
00000000 00000000 00000000 00000101   invert bits
00000000 00000000 00000000 00000110   add 1
                                      = 6

~x = -x - 1

~5 = -5 - 1
   = -6

Signed vs Unsigned: Same Bits, Different Meaning

~5 = 11111111 ... 11111010
                 ↓
                -6

8-bit concept:
5   = 00000101
~5  = 11111010
    = 250

Actual 32-bit Unsigned Example

unsigned int x = 5;

5  = 00000000 00000000 00000000 00000101
~5 = 11111111 11111111 11111111 11111010

Result = 4294967290

~x = UINT_MAX - x

~5 = 255 - 5
   = 250

Bitwise Shift Operators << and >>

5 = 00000101
5 << 1 = 00001010 = 10

5 = 00000101
5 >> 1 = 00000010 = 2

6.15 Logical Operators vs Bitwise Operators

This is one of the most common C interview and beginner mistakes because the symbols look similar.

int a = 5;
int b = 3;

printf("%d\n", a && b); /* 1: both values are nonzero */
printf("%d\n", a & b);   /* 1: 0101 & 0011 = 0001 */

The first expression asks a logical question. The second expression manipulates the binary representation bit by bit.

6.16 Shift Operators << and >>

Shift operators move the bits of an integer value. They are commonly used with masks and low-level data processing.

Left Shift

unsigned int x = 5;

/*
5       = 00000101
5 << 1  = 00001010 = 10
5 << 2  = 00010100 = 20
*/

For suitable unsigned values and valid shift counts, a left shift moves bits toward more significant positions and fills the low-order positions with zeroes. Do not blindly memorize that left shift always means multiplication by two; the statement is only safe under the appropriate value and shift conditions.

Right Shift

unsigned int x = 20;

/*
20       = 00010100
20 >> 1  = 00001010 = 10
20 >> 2  = 00000101 = 5
*/

For unsigned values, right shift moves bits toward less significant positions and fills the high-order positions with zeroes.

6.17 Unary Operators You Must Recognize

Unary operators work with one operand. Some of them become especially important when you later learn pointers and dynamic memory.

The last three forms will become much clearer when you learn pointers and type conversion in detail. For now, recognize them as important C syntax.

6.18 sizeof, Casts, Member Access and Other Important Operators

C has several operators that do not fit into simple arithmetic or logical categories.

sizeof Is an Operator, Not a Function

int x;

printf("%zu\n", sizeof(x));
printf("%zu\n", sizeof(int));

sizeof tells us the size in bytes of a type or object. The exact number of bytes occupied by a type depends on the implementation, so do not assume that every C implementation has the same sizes.

Explicit Type Conversion

int total = 5;
int count = 2;

double average = (double) total / count;

printf("%.2f", average); /* 2.50 */

Without the cast, total / count would be integer division because both operands are integers. The cast changes the calculation so that floating- point division is performed.

6.19 Type Conversion and Operators

The result of an operator depends not only on the symbol but also on the types of its operands. This is why the following two expressions behave differently:

int a = 5;
int b = 2;

printf("%d\n", a / b);          /* 2 */
printf("%.2f\n", (double)a / b); /* 2.50 */

Before performing many arithmetic operations, C applies its rules for integer promotions and usual arithmetic conversions. You do not need to memorize all of those rules at this stage, but you should remember this practical rule: always check the operand types before predicting the result.

6.20 Common Operator Mistakes

6.21 How to Read an Operator Expression Step by Step

When you see a difficult expression in a program or placement question, do not try to calculate everything mentally in one step. Use a systematic process.

Step 1 → Identify the variables and their types
        ↓
Step 2 → Identify each operator
        ↓
Step 3 → Check parentheses
        ↓
Step 4 → Determine which operation is evaluated first
        ↓
Step 5 → Calculate one operation at a time
        ↓
Step 6 → Check the resulting type
        ↓
Step 7 → Check whether any variable was modified
        ↓
Step 8 → Determine the final result

For example:

int a = 10;
int b = 3;
int result = a + b * 2;

Do not simply read from left to right. First identify that multiplication and addition are different operations. The detailed rules that determine grouping are covered in the dedicated Operator Precedence & Associativity topic. For now, use parentheses whenever they make your intended calculation clearer.

int result = a + (b * 2);

6.22 Operator Safety Checklist

• Check the data types of the operands.
• Know the difference between assignment = and equality ==.
• Remember that integer division discards the fractional part.
• Use % for integer remainder calculations.
• Never allow an unexpected zero divisor.
• Use && and || when combining conditions.
• Remember that logical operators short-circuit.
• Do not confuse logical operators with bitwise operators.
• Understand the difference between prefix and postfix increment/decrement.
• Avoid modifying the same variable multiple times in a complicated expression.
• Use unsigned types when deliberately manipulating bit patterns.
• Use valid shift counts.
• Use parentheses when they improve readability.
• Do not memorize output; trace the expression step by step.

6.23 Quick Revision

6.20 Quick MCQs

Select an answer first, then click Check Answer. A correct choice becomes green. If the choice is wrong, it becomes red and the correct option is shown in green. The correct answer and explanation appear below after checking.

Run your program to see the output.

#include <stdio.h>

int main()
{
    int a, b;

    scanf("%d %d", &a, &b);

    printf("Sum = %d\n", a + b);
    printf("Difference = %d\n", a - b);
    printf("Product = %d\n", a * b);
    printf("Quotient = %d\n", a / b);
    printf("Remainder = %d", a % b);

    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int n;

    scanf("%d", &n);

    printf("%s", (n % 2 == 0) ? "Even" : "Odd");

    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int a, b, c;
    int largest;

    scanf("%d %d %d", &a, &b, &c);

    if (a >= b && a >= c)
        largest = a;
    else if (b >= a && b >= c)
        largest = b;
    else
        largest = c;

    printf("Largest = %d", largest);

    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int a;
    int x, y;
    int pre, post;

    scanf("%d", &a);

    x = a;
    y = a;

    pre = ++x;
    post = y++;

    printf("Pre: value = %d, variable = %d\n", pre, x);
    printf("Post: value = %d, variable = %d", post, y);

    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int n;

    scanf("%d", &n);

    printf("%s",
           (n >= 10 && n <= 100)
           ? "Inside Range"
           : "Outside Range");

    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int a, b;
    int larger;

    scanf("%d %d", &a, &b);

    larger = (a > b) ? a : b;

    printf("Larger = %d", larger);

    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int a, b;

    scanf("%d %d", &a, &b);

    printf("AND = %d\n", a & b);
    printf("OR = %d\n", a | b);
    printf("XOR = %d", a ^ b);

    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    unsigned int n, k;

    scanf("%u %u", &n, &k);

    printf("Left Shift = %u\n", n << k);
    printf("Right Shift = %u", n >> k);

    return 0;
}

6.22 Key Takeaway