XQA
Back to C Programming
2026-07-127 min read

C Operators

Learn C Operators step by step with clear examples and exercises.

Title: Mastering C Operators: A full guide for Efficient Coding

Why This Matters

C operators are essential building blocks in C programming, enabling you to manipulate data, make decisions, and control the flow of your code effectively. Understanding them is crucial as they help you write efficient, error-free programs, prepare for interviews, and tackle real-world coding challenges.

Prerequisites

Before diving into C operators, it's essential to have a good understanding of:

  1. Basic C syntax (variables, constants, data types)
  2. Control structures (if, if-else, switch)
  3. Loops (for, while, do-while)
  4. Functions and function calls
  5. Arrays
  6. Pointers
  7. Understanding of basic mathematics concepts such as arithmetic operations, order of operations, and properties of numbers
  8. Familiarity with Boolean logic (true/false values and logical operators)
  9. Knowledge of bitwise representations of numbers

Core Concept

Overview of C Operators

C operators are symbols that perform specific operations on operands (variables, constants, or expressions). They can be categorized into the following types:

  1. Arithmetic operators
  2. Unary operators
  3. Relational operators
  4. Logical operators
  5. Bitwise operators
  6. Assignment operators
  7. Special operators

Arithmetic Operators

Arithmetic operators are used to perform mathematical operations on operands. They include:

  • Addition (+)
  • Subtraction (-)
  • Multiplication (*)
  • Division (/)
  • Modulus (%, remainder of division)
  • Increment (++) and decrement (--) operators

Examples

int a = 5;
int b = 3;
int sum = a + b; // sum equals 8
int product = a * b; // product equals 15

Unary Operators

Unary operators operate on a single operand. They include:

  • Negation (!, negates the value of an operand)
  • Address-of operator (&, returns the memory address of an operand)
  • Dereference operator (*, accesses the value stored at the memory address)
  • Increment (++) and decrement (--) operators when used as unary operators

Examples

int a = 5;
int *ptr = &a; // ptr points to the memory location of a
*ptr++; // increments the value stored at the memory location pointed by ptr, then dereferences it again

Relational Operators

Relational operators compare two operands and return a boolean value (true or false). They include:

  • Equal to (==)
  • Not equal to (!=)
  • Greater than (>)
  • Less than (<)
  • Greater than or equal to (>=)
  • Less than or equal to (<=)

Examples

int a = 5;
int b = 3;
if (a > b) {
printf("a is greater than b.\n"); // prints "a is greater than b."
} else if (a == b) {
printf("a is equal to b.\n"); // does not print anything since a and b are not equal
}

Logical Operators

Logical operators combine boolean expressions to produce a single boolean value. They include:

  • Logical AND (&&)
  • Logical OR (||)
  • Logical NOT (!)

Examples

int a = 5;
int b = 3;
if ((a > 4) && (b < 5)) {
printf("Both conditions are true.\n"); // prints "Both conditions are true."
} else {
printf("At least one condition is false.\n"); // prints "At least one condition is false."
}

Bitwise Operators

Bitwise operators manipulate the individual bits of their operands. They include:

  • Bitwise AND (&)
  • Bitwise OR (|)
  • Bitwise XOR (^)
  • Bitwise NOT (~)
  • Left shift (<<)
  • Right shift (>>)

Examples

int a = 0b1010; // binary representation of decimal 10
int b = 0b1101; // binary representation of decimal 13
int result = a & b; // bitwise AND operation, result equals 0b1000 (decimal 8)

Assignment Operators

Assignment operators assign the result of an expression to a variable. They include:

  • Simple assignment operator (=)
  • Compound assignment operators (+=, -=, *=, /=, %=, <<=, >>=)

Examples

int a = 5;
a += 3; // equivalent to a = a + 3, a now equals 8

Special Operators

Special operators include:

  • Ternary operator (?:)
  • Sizeof operator (sizeof)

Examples

int a = 5;
int b = (a > 4) ? 10 : 20; // ternary operator, b now equals 10 since a is greater than 4
int sizeOfInt = sizeof(int); // sizeof operator, sizeOfInt now equals the number of bytes occupied by an int on your system

Worked Example

Let's consider a more complex example to illustrate the usage of various C operators.

#include <stdio.h>

int main() {
int a = 5;
int b = 3;
char c = 'A';
float d = 3.14f;

// Arithmetic operators
int sum, product, difference, quotient, remainder;
sum = a + b;
product = a * b;
difference = a - b;
quotient = a / b;
remainder = a % b;
printf("Sum: %d\n", sum);
printf("Product: %d\n", product);
printf("Difference: %d\n", difference);
printf("Quotient: %.2f\n", (float)quotient); // cast to float for correct decimal output
printf("Remainder: %d\n", remainder);

// Unary operators
++a;
--b;
printf("Incremented a: %d\n", a);
printf("Decremented b: %d\n", b);

// Relational operators
if (a > b) {
printf("a is greater than b.\n");
} else if (a == b) {
printf("a is equal to b.\n");
} else {
printf("a is less than b.\n");
}

// Logical operators
if ((a > 5) && (b < 4)) {
printf("Both conditions are true.\n");
} else if ((a > 5) || (b < 3)) {
printf("At least one condition is true.\n");
} else {
printf("No conditions are true.\n");
}

// Bitwise operators
int mask = 0x0F;
int value = 0x1234;

value &= mask;
printf("Value after AND with mask: %#X\n", value);

// Ternary operator
int result = (value > 0xF) ? 1 : 0;
printf("Result of ternary operator: %d\n", result);

// Sizeof operator
int sizeOfChar = sizeof(char);
float sizeOfFloat = sizeof(float);
printf("Size of char: %d bytes\n", sizeOfChar);
printf("Size of float: %d bytes\n", sizeOfFloat);

return 0;
}

Common Mistakes

  1. Forgetting semicolons: Semicolons are essential in C, and forgetting them can lead to syntax errors.
  2. Incorrect operator usage: Using the wrong operator for a specific operation can result in incorrect results or compile-time errors.
  3. Misunderstanding precedence and associativity: Operators have different levels of precedence and associativity, which can affect the order of evaluation of expressions.
  4. Using bitwise operators on integers with different numbers of bits: Using a larger integer with a smaller one for bitwise operations may lead to unexpected results due to overflow or underflow.
  5. Neglecting the order of evaluation for assignment operators: Assignment operators have left-to-right associativity, which can sometimes lead to unintended consequences when using multiple assignments in a single expression.
  6. Using logical operators on non-boolean values: Logical operators expect boolean operands and will produce unexpected results if given non-boolean values.
  7. Neglecting the order of evaluation for bitwise operators: Bitwise operators are performed from right to left, which can sometimes lead to unintended consequences when using multiple bitwise operations in a single expression.
  8. Using the wrong type for a variable or constant: Using an incorrect data type for a variable or constant can lead to unexpected results and compile-time errors.
  9. Forgetting to initialize variables: Uninitialized variables may contain garbage values, leading to unpredictable behavior in your program.
  10. Not handling edge cases: Failing to handle edge cases (e.g., division by zero, out-of-bounds array access) can cause runtime errors or incorrect results.

Practice Questions

  1. Write a program that calculates the area and perimeter of a rectangle given its length and width.
  2. Given two integers a and b, write a program that checks if they are equal, greater than, or less than each other using relational operators.
  3. Write a program that swaps the values of two variables without using a temporary variable.
  4. Write a program that finds the factorial of a number using recursion and bitwise operators.
  5. Given an array of integers, write a program that sorts the array in ascending order using bitwise operators.
  6. Write a program that calculates the sum of all even numbers in an array using logical operators.
  7. Write a program that checks if a given number is prime or composite using bitwise operators and logical operators.
  8. Write a program that implements a simple calculator that performs addition, subtraction, multiplication, division, and modulus operations.
  9. Write a program that finds the maximum and minimum values in an array using relational operators and logical operators.
  10. Write a program that checks if two strings are anagrams of each other using character comparison and counting techniques.

FAQ

What is the difference between arithmetic and bitwise operators?

Arithmetic operators perform mathematical operations on operands, while bitwise operators manipulate the individual bits of their operands.

How do I handle edge cases in my code?

Edge cases are situations that may cause your program to behave unexpectedly or produce incorrect results. Handling them involves checking for conditions such as division by zero, out-of-bounds array access, and invalid input before performing calculations.

What is the order of evaluation for assignment operators in C?

Assignment operators have left-to-right associativity in C, which means that expressions like a = b = c are evaluated from left to right.

Why do I need to be careful when using bitwise operators on integers with different numbers of bits?

Using a larger integer with a smaller one for bitwise operations may lead to unexpected results due to overflow or underflow, as the smaller integer's bits will be padded with zeros if it is promoted to the size of the larger integer.

What are some common mistakes to avoid when using C operators?

Common mistakes include forgetting semicolons, incorrect operator usage, misunderstanding precedence and associativity, neglecting edge cases, and using logical operators on non-boolean values.