Types of Operators in C: Explained with Examples (2026)

The C programming language utilizes various types of operators to perform operations on data. These operators can be categorized as Arithmetic, Relational, Logical, Bitwise, Assignment, and Conditional operators. Mastering these symbols is critical for manipulating data at the bit level and ensuring efficient memory management.

In this guide, you’ll read more about the specific functions and syntax of every operator category. We will break down types of operators in C with real-world coding examples.

Want to take charge of your data science journey? Join our Data Science Courses and step into the industry with confidence!

Quick Overview of Types of Operators in C

Operators are symbols or keywords that tell you to carry out specific actions. For example, in the 'a + b' expression, the '+' operator directs the system to add the two operands, a and b. Operands can be variables, constants, or even entire expressions.
Below is a brief table showing the major types of opreators :

Types of Operators in C In Detail

When analyzing the operators in C language, we generally classify them into six distinct categories based on their functionality. Understanding these different types of operators is crucial because choosing the right one directly impacts the memory efficiency and speed of your application.

1. Arithmetic Operators

Arithmetic operators are likely the first types of operators in C you will encounter. They perform standard mathematical calculations such as addition (+), subtraction (-), multiplication (*), and division (/). Additionally, the modulus operator (%) is uniquely useful in programming for finding remainders. These operators in C language form the building blocks for logic involving counters, loops, and complex mathematical algorithms.

Here are the 9 types of arithmetic operators in C:

Please Note: In C, each statement ends with a semicolon (;). It’s simply a statement terminator that tells the compiler, “This line of code ends here.” For instance, when you write result = a + b;, the semicolon indicates that this assignment statement is complete.

Example of Arithmetic Operators in C

This sample program shows how to add, multiply, and find remainders, along with incrementing and decrementing variables. By observing how each operator modifies the values of ‘x’ and ‘y’, you can see how arithmetic operators streamline calculations in a straightforward way.

#include <stdio.h>

int main() {
    int a = 10, b = 3;
    
    // Unary Plus and Unary Minus
    int positiveA = +a;
    int negativeA = -a;
    
    // Basic Arithmetic
    int sum = a + b;
    int difference = a - b;
    int product = a * b;
    int quotient = a / b;
    int remainder = a % b;

    // Increment and Decrement
    a++;    
    b--;

    printf("Unary plus of a: %d\n", positiveA);
    printf("Unary minus of a: %d\n", negativeA);
    printf("Sum (a + b): %d\n", sum);
    printf("Difference (a - b): %d\n", difference);
    printf("Product (a * b): %d\n", product);
    printf("Quotient (a / b): %d\n", quotient);
    printf("Remainder (a %% b): %d\n", remainder);
    printf("After Increment, a: %d\n", a);
    printf("After Decrement, b: %d\n", b);

    return 0;
}

Output:
Unary plus of a: 10
Unary minus of a: -10
Sum (a + b): 13
Difference (a - b): 7
Product (a * b): 30
Quotient (a / b): 3
Remainder (a % b): 1
After Increment, a: 11
After Decrement, b: 2

Real-World Uses of Arithmetic Operators

Also Read: What is Array in C? With Examples

2. Assignment Operators

Assignment operators in C help you store or update the value of a variable. The most basic form is =, which assigns the right-hand value to the left-hand variable. Beyond that, compound assignment operators like += or -= combine arithmetic and assignment in one step. This can reduce code repetition and make expressions more concise.

Below is a look at all the 11 assignment operator types you might encounter in the C programming language.

Example of Assignment Operators in C

The following program shows all 11 types of assignment operators in action. You’ll see how they modify a variable’s value step by step, including simple arithmetic and bitwise changes.

#include <stdio.h>

int main() {
    int a = 10, b = 3;

    // Simple Assignment
    printf("Initial value of a: %d\n", a);

    // Add and Assign
    a += b; // a = a + b
    printf("After a += b, a: %d\n", a);

    // Subtract and Assign
    a -= b; // a = a - b
    printf("After a -= b, a: %d\n", a);

    // Multiply and Assign
    a *= b; // a = a * b
    printf("After a *= b, a: %d\n", a);

    // Divide and Assign
    a /= b; // a = a / b
    printf("After a /= b, a: %d\n", a);

    // Modulus and Assign
    a %= b; // a = a % b
    printf("After a %%= b, a: %d\n", a);

    // Reset a to 10 for bitwise operations
    a = 10;

    // Left Shift and Assign
    a <<= 1; // a = a << 1
    printf("After a <<= 1, a: %d\n", a);

    // Right Shift and Assign
    a >>= 1; // a = a >> 1
    printf("After a >>= 1, a: %d\n", a);

    // Reset a to 10 for bitwise AND
    a = 10;
    a &= b; // a = a & b
    printf("After a &= b, a: %d\n", a);

    // Reset a to 10 for bitwise OR
    a = 10;
    a |= b; // a = a | b
    printf("After a |= b, a: %d\n", a);

    // Reset a to 10 for bitwise XOR
    a = 10;
    a ^= b; // a = a ^ b
    printf("After a ^= b, a: %d\n", a);

    return 0;
}

Output: 
Initial value of a: 10
After a += b, a: 13
After a -= b, a: 10
After a *= b, a: 30
After a /= b, a: 10
After a %= b, a: 1
After a <<= 1, a: 20
After a >>= 1, a: 10
After a &= b, a: 2
After a |= b, a: 11
After a ^= b, a: 9

Real-World Uses of Assignment Operators

3. Relational Operators

Relational operators are essential for decision-making. Among the various types of operators in C, these are used to compare two values, returning either true (1) or false (0). Common symbols include == (equal to), != (not equal), and > (greater than). Mastery of these operators in C language is mandatory for controlling the flow of your program using conditional statements like if and while loops.

Here’s an overview of all the 6 types of relational operators in C:

Example of Relational Operators in C

The following program checks various conditions on two integers and prints whether those conditions are true or false. This helps illustrate how each relational operator can be used for comparisons in everyday coding tasks.

• x < y checks if x is strictly less than y.
• x > y checks if x is strictly greater than y.
• x <= y checks if x is less than or equal to y.
• x >= y checks if x is greater than or equal to y.
• x == y checks if both operands have the same value.
• x != y checks if the two operands have different values.

#include <stdio.h>

int main() {
    int x = 10, y = 3;
    printf("x < y  : %d\n", x < y);
    printf("x > y  : %d\n", x > y);
    printf("x <= y : %d\n", x <= y);
    printf("x >= y : %d\n", x >= y);
    printf("x == y : %d\n", x == y);
    printf("x != y : %d\n", x != y);

    return 0;
}

Output: 
x < y  : 0
x > y  : 1
x <= y : 0
x >= y : 1
x == y : 0
x != y : 1

Real-World Uses of Relational Operators

You can also check out upGrad’s tutorial, ‘For Loop in C’. Discover how the loop works, its types, syntax, and more.

4. Logical Operators

Logical operators in C let you combine or invert multiple conditions in a single expression. 

• They return 1 (true) when the condition holds and 0 (false) otherwise. 
• You can check multiple constraints with logical AND (&&) or logical OR (||)
• You can flip a condition’s outcome using logical NOT (!). 

These types of operators in C are essential in loops, conditional statements, and error-handling routines because they give you greater control over the flow of your program. They also help you write clearer, more readable conditions instead of nesting numerous if-else blocks.

Here are the 3 types of logical operators in C:

Example of Logical Operators in C

The following program shows how each logical operator works by evaluating conditions on two integers. You’ll see how combining checks can simplify decision-making and reduce multiple nested if statements.

• x < 10 && y > 5 checks if x is less than 10 and y is greater than 5.
• x > 10 || y == 10 checks if x is greater than 10 or y equals 10.
• !(x < y) flips the outcome of (x < y). If (x < y) is true, adding ! makes it false.

#include <stdio.h>

int main() {
    int x = 5, y = 10;
    
    // Logical AND
    printf("x < 10 && y > 5  : %d\n", (x < 10) && (y > 5));
    
    // Logical OR
    printf("x > 10 || y == 10: %d\n", (x > 10) || (y == 10));
    
    // Logical NOT
    printf("!(x < y)         : %d\n", !(x < y));
    
    return 0;
}

Output: 
x < 10 && y > 5  : 1
x > 10 || y == 10: 1
!(x < y)         : 0

Real-World Uses of Logical Operators

5. Bitwise Operators

Bitwise operators work directly on the binary representation of data, making them unique among the types of operators in C. They include operations like AND (&), OR (|), XOR (^), and Bit Shift (<<, >>). Because C is often used for system-level programming, these operators in C language are critical for tasks requiring hardware manipulation, data compression, and setting specific "flags" in memory-constrained environments.

Here are the 6 types of Bitwise operators explained:

Example of Bitwise Operators in C

The following code demonstrates how bitwise operations in C affect the binary representation of two integers. You can see how each operator changes the bits, which is critical for tasks like flag management or fast calculations in embedded programming.

• x & y performs a bitwise AND on 0101 and 0011.
• x | y performs a bitwise OR on 0101 and 0011.
• x ^ y is a bitwise XOR, which is 1 for bits that differ.
• ~x flips all bits in x.
• x << 1 shifts bits of x to the left by 1, adding a 0 on the right.
• x >> 1 shifts bits of x to the right by 1, typically inserting a 0 on the left.

#include <stdio.h>

int main() {
    int x = 5, y = 3; // In binary: x = 0101, y = 0011

    printf("x & y: %d\n", x & y);
    printf("x | y: %d\n", x | y);
    printf("x ^ y: %d\n", x ^ y);
    printf("~x  : %d\n", ~x);
    printf("x << 1: %d\n", x << 1);
    printf("x >> 1: %d\n", x >> 1);

    return 0;
}

Output: 
x & y: 1
x | y: 7
x ^ y: 6
~x  : -6
x << 1: 10
x >> 1: 2

Real-World Uses of Bitwise Operators

6. Special & Miscellaneous Operators 

Beyond arithmetic, relational, logical, bitwise, and assignment types of operators, C includes a range of specialized ones that handle memory addresses, structure references, and more advanced tasks. 

Let’s explore each special C operator in detail.

Conditional Operator in C

The conditional operator offers a compact way to handle simple decision-making in your programs. It evaluates a condition and selects one of two expressions based on whether the condition is true or false. 

Unlike an if-else statement, which spans multiple lines, the conditional operator fits into a single expression, often making code more concise. It can streamline tasks such as choosing between two values, setting defaults, or performing quick validations. 

Because it involves three operands — a condition and two results — it’s the only operator in C that requires three parts.

Here are the crucial details of conditional operator in C:

Example of Conditional Operator in C

Here’s a short program illustrating how it decides between two values based on a logical check:

• The condition (score >= 40) checks whether the score is 40 or above.
• If true, it picks "Pass". Otherwise, it picks "Fail".
• The chosen string is stored in the result, which is then printed.

#include <stdio.h>

int main() {
    int score = 75;
    const char* result = (score >= 40) ? "Pass" : "Fail";
    
    printf("Exam Result: %s\n", result);
    return 0;
}

Output: 
Exam Result: Pass

Uses of the Conditional Operator

sizeof Operator in C

The sizeof operator in C tells you how much memory a data type or variable needs, measured in bytes. It’s evaluated during compilation, so it doesn’t slow down your program at runtime. 

You might use sizeof to determine array lengths, allocate memory dynamically, or confirm that certain data types meet specific size requirements. Because C implementations can vary in how many bytes they assign to each type, sizeof is one of the most reliable ways to ensure consistent, portable code.

Here are the crucial details about sizeof operator in C:

Example of sizeof Operator in C

Here’s a brief program that prints the sizes of common data types:

• Each call to sizeof checks how many bytes the data type occupies in the current environment.
• %zu is the recommended format specifier for variables of type size_t.

#include <stdio.h>

int main() {
    printf("Size of int: %zu bytes\n", sizeof(int));
    printf("Size of float: %zu bytes\n", sizeof(float));
    printf("Size of double: %zu bytes\n", sizeof(double));
    printf("Size of char: %zu byte\n", sizeof(char));
    return 0;
}

Output:
Size of int: 4 bytes
Size of float: 4 bytes
Size of double: 8 bytes
Size of char: 1 byte

Uses of the sizeof Operator

Comma Operator in C

The comma operator allows multiple expressions to be evaluated and executed in a single statement. Despite looking similar to the commas that separate function parameters, it works differently by evaluating each expression from left to right and returning the value of the last expression. 

This operator in C can simplify code when you want to combine related tasks in one place, such as initializing multiple variables in a loop. Keep in mind that each expression is evaluated in sequence, but intermediate results are not stored unless explicitly assigned.

Here are the critical details about the comma operator in C programming: 

Example of Comma Operator in C

Below is a program that uses the comma operator to initialize and update multiple variables in a single line:

• b is assigned the value 2.
• c is then set to b + 3, which becomes 5.
• Finally, c * 2 is computed (5 * 2 = 10) and assigned to a.

#include <stdio.h>

int main() {
    int a, b, c;
    a = (b = 2, c = b + 3, c * 2); 
    // Here, b is set to 2, c becomes 5, and finally a is assigned c * 2 = 10

    printf("a: %d\n", a);
    printf("b: %d\n", b);
    printf("c: %d\n", c);

    return 0;
}

Output: 
a: 10
b: 2
c: 5

Uses of the Comma Operator

Dot (.) and Arrow (->) Operators in C

The dot (.) and arrow (->) operators help you access members within structures and unions. 

• The dot operator works directly on an instance of a structure, letting you retrieve or set a specific field. 
• The arrow operator, on the other hand, is used when you have a pointer to a structure: it dereferences the pointer and then accesses the member. 

Both these types of operators make it easier to handle complex data types by cleanly referring to individual elements without cluttering your code with extra dereferencing steps. In many data structures — like linked lists or trees — these operators come into play frequently.

Here are some important details about these two types of operators:

Example of Dot and Arrow Operators in C

Below is a simple program showing how both operators are used with a structure and a pointer to that structure:

• p1 is a structure of type Point with x = 10 and y = 20.
• ptr stores the address of p1.
• p1.x and p1.y directly access the members of p1.
• ptr->x and ptr->y dereference ptr and then access the members, equivalent to (*ptr).x and (*ptr).y.

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main() {
    struct Point p1 = {10, 20};
    struct Point* ptr = &p1;

    // Using the dot operator
    printf("p1.x using dot: %d\n", p1.x);
    printf("p1.y using dot: %d\n", p1.y);

    // Using the arrow operator
    printf("ptr->x using arrow: %d\n", ptr->x);
    printf("ptr->y using arrow: %d\n", ptr->y);

    return 0;
}

Output:
p1.x using dot: 10
p1.y using dot: 20
ptr->x using arrow: 10
ptr->y using arrow: 20

Uses of Dot (.) and Arrow (->) Operators in C

Address-of (&) and Dereference (*) Operators in C

Pointers are a powerful feature in C, and the address-of (&) and dereference (*) operators lie at the heart of this mechanism. 

• The & operator retrieves the memory address of a variable, turning it into a pointer. 
• Meanwhile, the * operator (used on a pointer) grants access to the data at that address.

By combining these two types of operators, you can work with memory directly, which is helpful for tasks like dynamic memory allocation, creating complex data structures, or passing large data efficiently. Although they might seem tricky at first, a solid grasp of & and * is key to writing flexible and optimized code in C.

Here are some key details you should know:

Example of Address-of (&) and Dereference (*) Operators in C

Below is a simple program to show how to take a variable’s address, store it in a pointer, and then use dereferencing to access the original data:

• int *ptr = &num; takes the address of num and stores it in the pointer ptr.
• *ptr gives the value at the address held by ptr, effectively letting you read or write num via ptr.
• Changing *ptr updates num because both refer to the same memory location.

#include <stdio.h>

int main() {
    int num = 42;
    int *ptr = &num; // Address-of operator used to get num's address

    printf("Address of num: %p\n", (void*)&num);
    printf("Value of ptr (which is &num): %p\n", (void*)ptr);
    printf("Value pointed to by ptr (*ptr): %d\n", *ptr);

    // Modifying the value via pointer
    *ptr = 100;
    printf("Updated value of num after *ptr = 100: %d\n", num);

    return 0;
}

Output:
Address of num: 0x7ffeea7ac9bc      // Example address; will vary
Value of ptr (which is &num): 0x7ffeea7ac9bc
Value pointed to by ptr (*ptr): 42
Updated value of num after *ptr = 100: 100

Uses of Address-of (&) and Dereference (*) Operators

Operator Precedence and Associativity in C

Operator precedence and associativity determine the order in which parts of an expression are evaluated. When multiple operators appear in the same statement, precedence dictates which operator runs first, and associativity decides how operators of the same level group together. 

Being aware of these rules prevents unexpected results, especially in complex expressions. It also helps you write clearer code: well-placed parentheses can override default precedence, making your intent obvious to both the compiler and anyone reading your work. 

Below is a streamlined overview that shows how operators stack up in priority.

Example of Operator Precedence and Associativity in C

Here’s a program that demonstrates how precedence and associativity can affect an expression’s outcome. Changing parentheses can lead to different results if you’re not careful.

• a + b * c follows precedence rules: b * c happens first, giving 3 * 4 = 12, then 2 + 12 = 14.
• (a + b) * c uses parentheses to change the order, so a + b becomes 5, then multiplied by c = 4, resulting in 20.

#include <stdio.h>

int main() {
    int a = 2, b = 3, c = 4;
    int result1 = a + b * c;       // Multiplication first, then addition
    int result2 = (a + b) * c;     // Parentheses override default precedence

    printf("Without parentheses: %d\n", result1);
    printf("With parentheses   : %d\n", result2);

    return 0;
}

Output:
Without parentheses: 14
With parentheses : 20

Uses of Operator Precedence and Associativity

Unary, Binary, and Ternary Operators in C

Operators in C are often described by how many operands they work with. 

• A unary operator needs one operand
• A binary operator works with two
• A ternary operator uses three. 

Understanding these categories clarifies how different operators function and helps you choose the most appropriate one for a given task.

Here are some crucial details:

Example Demonstrating Unary, Binary, and Ternary Types of Operators

Below is a simple program that shows how these three categories of operators can appear in a single piece of code:

• Unary Operator (++a): Increases the value of a by 1, changing it from 5 to 6.
• Binary Operator (a + b): Adds the new a (6) and b (3), giving 9.
• Ternary Operator ((a > b) ? a : b): Checks if a is greater than b. Since 6 > 3 is true, it returns a.

#include <stdio.h>

int main() {
    int a = 5, b = 3;

    // Unary: Increment 'a'
    ++a; // a becomes 6

    // Binary: Add 'a' and 'b'
    int sum = a + b; // 6 + 3 = 9

    // Ternary: Check which is bigger
    int bigger = (a > b) ? a : b; // evaluates to 6

    printf("After unary increment, a: %d\n", a);
    printf("Sum of a and b: %d\n", sum);
    printf("Bigger number: %d\n", bigger);

    return 0;
}

Output:
After unary increment, a: 6
Sum of a and b: 9
Bigger number: 6

Uses of Unary, Binary, and Ternary Operators

Common Mistakes with Operators in C Language

Even experienced developers can stumble when working with the various types of operators in C. Misunderstanding precedence or syntax can lead to bugs that are difficult to trace.

Below are the most frequent errors developers make when using operators in C language and how to avoid them.

• Incorrect Operator Precedence: Forgetting precedence rules can lead to unexpected results. Always use parentheses to clarify the order of operations.
• Misuse of Assignment Operator (=) and Relational Operator (==): Confusing these operators can cause logic errors, especially in conditional statements.
• Division by Zero: Performing division without checking for zero results in runtime errors.
• Mismatched Data Types: Using incompatible data types can lead to truncation or unexpected behavior.
• Overusing Increment and Decrement Operators: Using ++ or -- multiple times in a single expression can confuse the logic and readability of your code.
• Ignoring Type Conversions: Implicit type conversions can lead to precision loss or data corruption. Use explicit casting to control conversions.
• Incorrect Use of Logical Operators: Misusing && and || can result in faulty condition evaluations.

Avoiding these mistakes ensures your code is both accurate and maintainable. This sets the stage for implementing best practices to write efficient C programs.

Best Practices for Using Operators in C

Writing clean and efficient code involves a combination of smart operator usage and optimization techniques. Following best practices simplifies debugging and enhances code performance.

Below are practical tips for working with types of operators in C and writing efficient code.

• Choose Operators Wisely: Use the most appropriate operator for the task. For example, prefer bitwise operators for low-level programming tasks.
• Make Use of Special Operators in C Programming: Operators like sizeof and conditional operators can simplify complex tasks and reduce redundancy.
• Use Parentheses for Clarity: Parentheses override default precedence and make expressions more readable.
• Optimize Performance with Bitwise Operators: Bitwise operations are faster and use fewer resources than arithmetic operations in certain scenarios.
• Avoid Deeply Nested Conditions: Refactor nested conditions using ternary or logical operators to enhance readability.
• Comment Complex Expressions: Document intricate logic to help others understand your code quickly.
• Minimize Side Effects: Avoid using operators like ++ or -- in complex expressions, as they can introduce hidden bugs.
• Test for Boundary Conditions: Ensure operators behave correctly at edge cases, such as large numbers or zero values.

Also Read: How to Become a Software Engineer in India? 7 Actional Steps

How Can upGrad Help You?

If you aim to deepen your understanding of programming and advance your career, upGrad is here to guide you. With over 10 million learners worldwide, 200+ expertly designed courses, and partnerships with 1400+ hiring companies, upGrad equips you with the knowledge and skills needed to thrive in a competitive environment.

Below are some courses from upGrad that align with mastering all types of operators in C and programming fundamentals.

• Data Structures and Algorithms
• Cloud Engineering Bootcamp

You also have access to personalized one-on-one expert career counseling. These sessions help you identify your goals, improve your resume, and craft a career strategy tailored to your skills.

Reference Link: 
https://www.statista.com/statistics/793628/worldwide-developer-survey-most-used-languages/