In programming, an operator is a special symbol that tells the compiler to perform a specific mathematical, relational, or logical manipulation.

To understand operators, you need to know three terms:

Operator: The symbol performing the action (e.g., +, -).
Operand: The data values or variables on which the operator acts (e.g., in a + b, a and b are operands).
Expression: A combination of operators and operands that evaluates to a single value (e.g., 5 + 3 evaluates to 8).

C is rich in built-in operators. Let's look at the most essential categories.

1. Arithmetic Operators

Arithmetic operators are used to perform basic mathematical calculations on numeric values.

Operator	Meaning	Example (`a = 10, b = 3`)	Result
`+`	Addition	`a + b`	`13`
`-`	Subtraction	`a - b`	`7`
`*`	Multiplication	`a * b`	`30`
`/`	Division	`a / b`	`3` (Integer Division)
`%`	Modulo (Remainder)	`a % b`	`1`

Two Critical Rules for Arithmetic in C:

Integer Division vs. Float Division:
- If both operands are integers, the result is truncated to an integer: 10 / 4 gives 2, not 2.5.
- If at least one operand is a float, the result is a float: 10.0 / 4 or 10 / 4.0 gives 2.5.
The Modulo Operator (%):
- The % operator computes the remainder of an integer division.
- It only works with integers. Writing 5.5 % 2 will cause a compiler error.

Division by zero (e.g., x / 0 or x % 0) is undefined behaviour in C. It will cause your program to crash immediately at runtime (Floating Point Exception / Crash).

2. Increment and Decrement Operators

C provides two special unary operators (operators that act on a single operand):

++ (Increment: increases value by 1)
-- (Decrement: decreases value by 1)

These can be placed before the variable (Prefix) or after the variable (Postfix).

Pre-Increment (`++a`) vs. Post-Increment (`a++`)

Prefix (++a): Change first, use later. The value is incremented by 1 before it is evaluated in the expression.
Postfix (a++): Use first, change later. The original value is used in the expression, and then incremented afterward.

#include <stdio.h>

int main() {

int x = 5, y = 5;

int a, b;

    a = ++x;  // x becomes 6, then a is assigned 6

    b = y++;  // b is assigned 5, then y becomes 6

printf("Prefix  -> x: %d, a: %d\n", x, a);

printf("Postfix -> y: %d, b: %d\n", y, b);

return 0;

}

Output:

Prefix  -> x: 6, a: 6
Postfix -> y: 6, b: 5

Pre vs. Post increment is a classic exam and interview question! Remember: Prefix = Increment first, Postfix = Use current value first.

3. Relational Operators

Relational operators are used to compare two values. The result of a comparison in C is always a boolean value:

1 represents True
0 represents False

Operator	Meaning	Example (`a = 10, b = 20`)	Result
`==`	Equal to	`a == b`	`0` (False)
`!=`	Not equal to	`a != b`	`1` (True)
`>`	Greater than	`a > b`	`0` (False)
`<`	Less than	`a < b`	`1` (True)
`>=`	Greater than or equal to	`a >= 10`	`1` (True)
`<=`	Less than or equal to	`b <= 15`	`0` (False)

Do not confuse the assignment operator = with the comparison operator ==!

if (a = 5) assigns 5 to a and always evaluates to True.
if (a == 5) checks if a is equal to 5. This is one of the most notorious logical bugs in C.

4. Logical Operators

Logical operators are used to combine multiple relational conditions.

Operator	Name	Description	Example
`&&`	Logical AND	Returns `1` only if both conditions are true	`(a > 5) && (b < 10)`
`\|\|`	Logical OR	Returns `1` if at least one condition is true	`(a > 5) \|\| (b < 10)`
`!`	Logical NOT	Inverts the truth value (True becomes False, and vice-versa)	`!(a == b)`

Truth Table

Condition A	Condition B	`A && B`	`A \|\| B`	`!A`
True (1)	True (1)	1	1	0
True (1)	False (0)	0	1	0
False (0)	True (1)	0	1	1
False (0)	False (0)	0	0	1

Short-Circuit Evaluation

C uses short-circuit evaluation for logical operators to optimize speed:

In A && B: If A is false (0), the entire expression is guaranteed to be false, so B is not even evaluated.
In A || B: If A is true (1), the entire expression is guaranteed to be true, so B is skipped.

5. Assignment and Compound Assignment Operators

The simple assignment operator = assigns the value on the right-hand side to the variable on the left-hand side.

C also provides Compound Assignment Operators as shortcuts to perform an operation and assign the result back in one step:

Operator	Equivalent To	Example
`+=`	`a = a + b`	`x += 5;`
`-=`	`a = a - b`	`x -= 2;`
`*=`	`a = a * b`	`x *= 3;`
`/=`	`a = a / b`	`x /= 4;`
`%=`	`a = a % b`	`x %= 2;`

Complete Practical Example

#include <stdio.h>

int main() {

int marks = 78;

int attendance = 85;

// Relational and Logical checks

if (marks >= 40 && attendance >= 75) {

printf("Status: Eligible for Final Examination.\n");

    } else {

printf("Status: Not Eligible.\n");

    }

// Compound assignment & Modulo check

int number = 17;

int isEven = (number % 2 == 0);

printf("Is %d even? %d (0 = No, 1 = Yes)\n", number, isEven);

return 0;

}

Output:

Status: Eligible for Final Examination.
Is 17 even? 0 (0 = No, 1 = Yes)

Summary

Arithmetic operators (+, -, *, /, %) perform mathematical computations. Modulo (%) only works on integers.
Prefix (++x) increments before value usage; Postfix (x++) increments after value usage.
Relational operators return 1 for true and 0 for false.
Logical operators (&&, ||, !) combine multiple conditions and employ short-circuit evaluation.
Compound assignment operators (+=, -=, etc.) provide concise syntax for updating variable values.

Two-Dimensional (2D) Arrays in C

1. Declaring a 2D Array

Unlock Full Lesson