Types of Operators in C: Roles, Usage & Best Practices 2025

Did you know? As per Statista, C is the world's 10th most popular programming language, right after C# and C++. Many developers choose it for its direct control over hardware resources, which makes it an excellent option for building everything from embedded devices to operating systems.

One reason behind C’s enduring appeal lies in how it handles core operations, known as operators. These form the basis for arithmetic, comparisons, and logical decisions in your code. If you skip understanding different types of operators in C, you risk hours of debugging or unexpected behavior.

This guide thoroughly explores all the types of operators in C, from arithmetic to bitwise, with practical examples you can try immediately. You'll have a strong foundation for writing cleaner, more effective C programs by the end.

What is an Operator, and What are its Types 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.

Understanding how different types of operators work is important for tasks such as arithmetic, comparisons, and pointer manipulation.

Below is a brief table showing the major types of operators in C:

Up next, you’ll see how each operator type works in actual C programs, complete with examples you can test on your own.

What are the Different Types of Operators in C?

Operators in C go beyond basic math tasks. They handle comparisons, logical checks, data manipulation, and even pointer operations. Grouping them based on their purpose can help you plan and write code that’s easier to understand and maintain.

In the next sections, you'll see how each category works and examples showing why these operators are key to solving real coding challenges.

1. Arithmetic Operators

Arithmetic operators in C handle a range of numeric tasks, from simple addition and subtraction to finding remainders with the modulus operator (%). You can also increment or decrement a variable with ‘++’ and ‘--’, which is handy for loops or counters. 

These operators act on integer and floating-point data types, letting you combine multiple operations in a single expression. Knowing each one allows you to manage calculations more efficiently in your programs.

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 compare two operands and return either 1 (true) or 0 (false). You’ll see them in conditional statements, loops, and any code that checks whether values match certain criteria.

They can help validate user input, ensure ranges are met, or detect whether one piece of data exceeds another. By mastering these types of operators, you’ll have more control over logical flows and decision-making in your programs.

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 in C revolve around the binary representation of integers, letting you manipulate individual bits directly. They can be pivotal for tasks like controlling hardware registers, toggling flags, or compressing multiple settings into a single variable. 

You can perform quick calculations or implement simple encryption by shifting, combining, or flipping bits. Each operator tackles bits differently: some merge bits from two operands, while others shift them left or right, or invert them altogether. 

Mastering the different types of operators in the Bitwise category can lead to more efficient and compact code in resource-constrained projects.

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 Types of Operators in C 

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

upGrad’s Exclusive Software Development Webinar for you –

SAAS Business – What is So Different?

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

What are Some Common Mistakes to Avoid When Using Operators in C?

Even seasoned programmers encounter errors when working with operators in C. Avoiding these pitfalls can save time and ensure your program behaves as expected.

Below are common mistakes you should watch out for when working with different types of operators in C.

• 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.

What Are Some Best Practices for Writing Clean and Efficient Code 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.

• Full Stack Development Bootcamp - Essential
• Professional Certificate Program in Cloud Computing and DevOps
• 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.

Boost your career with our popular Software Engineering courses, offering hands-on training and expert guidance to turn you into a skilled software developer.

Explore our Popular Software Engineering Courses

Master in-demand Software Development skills like coding, system design, DevOps, and agile methodologies to excel in today’s competitive tech industry.

In-Demand Software Development Skills

Stay informed with our widely-read Software Development articles, covering everything from coding techniques to the latest advancements in software engineering.

Read our Popular Articles related to Software

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