➕ 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");

In these examples, one expression compares marks, another increases salary, and another combines two conditions. The operator determines the action in each case.

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?

When both operands are integers, / gives an integer quotient. C discards the fractional part; it does not round to the nearest integer. For example, 7 / 2 gives 3 and -7 / 2 gives -3.

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 remainder operator gives what is left after integer division. For example, 17 % 10 gives 7, the last digit of 17. It is also useful for checking whether a number is even or odd.

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

For a simple assignment to a variable, C calculates the right-hand value, converts it to the variable’s type if necessary, and stores it. The previous value of the variable is replaced.

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

A compound assignment updates a variable using its current value. It combines the calculation and assignment in one short form.

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);

The examples above change the same variable in ways that C does not order safely. Their behavior is undefined: C gives no reliable output to predict. Adding parentheses does not solve this problem. Write the updates as separate statements instead.

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 an unsigned operand, a valid left shift moves bits left and fills the right-hand positions with zeros. Bits shifted beyond the type’s width are lost. Therefore the result need not equal ordinary multiplication if that multiplication would exceed the range.

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.

You will use address-of and dereference when studying pointers. A cast changes the type used for a value in an expression. Recognize these forms now; later lessons explain them with complete examples.

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 gives the size in C bytes. A C byte contains at least eight bits, and the size of a type can vary between implementations. Use the result reported by your compiler instead of assuming that every int uses four bytes.

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 divide two integers and discard the fractional part. Casting one operand before division makes this a floating-point calculation.

6.19 Type Conversion and Operators

Before calculating an expression, check the operand types. The same operator can give different results with integer and floating-point operands:

int a = 5;
int b = 2;

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

C sometimes converts operands before calculating a result. These rules are called integer promotions and usual arithmetic conversions. Start with this habit: 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

Read a difficult expression in small steps: identify the values, check their types, and work out the grouping before calculating the answer.

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.

#include <stdio.h>
#include <limits.h>

int main(void)
{
    int a = INT_MAX, b = 1;
    if (b > 0 && a > INT_MAX - b)
        puts("Addition would overflow");
    else
        printf("Sum: %d\n", a + b);
    return 0;
}

Addition would overflow

6.24 Quick Revision

6.25 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.27 Key Takeaway