Operators in C


One of the core building blocks of C programming is the wide range of operators it offers. Operators in C are symbols or special keywords that manipulate data and perform various operations on variables.

This article dives deep into the world of Operators in C, exploring their significance, functions, and practical applications. Whether you’re a novice looking to learn the fundamentals or an experienced programmer seeking a refresher, this guide is your gateway to mastering C operators.

Operators in C

1. Relational Operators: Comparing Values

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

Relational operators play a pivotal role in decision-making statements and loops, as they help evaluate conditions and control the flow of the program.

2. Logical Operators: Making Logical Decisions

&&Logical AND
||Logical OR
!Logical NOT

These operators are instrumental in forming compound conditions, which are essential for implementing conditional statements and loop controls.

3. Bitwise Operators: Manipulating Individual Bits

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

Bitwise operators are particularly useful in scenarios where memory optimization or low-level hardware interactions are required.

4. Assignment Operators: Assigning Values

+=Add and assign
-=Subtract and assign
*=Multiply and assign
/=Divide and assign
%=Modulo and assign
<<=Left shift and assign
>>=Right shift and assign
&=Bitwise AND and assign
|=Bitwise OR and assign
^=Bitwise XOR and assign

These operators streamline the process of assigning values to variables, making code concise and more readable.

Advanced Operators in C

Building upon the basics, let’s explore some advanced operators in C that expand the capabilities of your code.

1. sizeof Operator: Determining Memory Size

The sizeof operator in C allows you to determine the size, in bytes, of a data type or variable. It helps optimize memory usage and is often used in conjunction with dynamic memory allocation.


#include <stdio.h>
int main() {
    int num;
    printf("Size of int data type: %zu bytes", sizeof(num));
    return 0;

2. Comma Operator: Sequencing Expressions

The comma operator evaluates multiple expressions and returns the value of the last expression. It is useful in situations where multiple actions need to be executed sequentially in a single statement.


#include <stdio.h>
int main() {
    int x, y;
    x = 10, y = 20;
    printf("Value of x: %d, Value of y: %d", x, y);
    return 0;

3. Pointer Operators: Managing Memory Addresses

Pointers are a powerful concept in C, and pointer operators help manipulate and access memory addresses. The two main pointer operators are:

  • & (Address of operator): Returns the memory address of a variable.
  • * (Value at address operator): Accesses the value at the given memory address.

Pointers are crucial for dynamic memory allocation and complex data structures like linked lists.


#include <stdio.h>
int main() {
    int num = 42;
    int *ptr = #
    printf("Value at the address %p is %d", ptr, *ptr);
    return 0;

4. Bitwise Shift Operators: Data Manipulation

Bitwise shift operators perform shifting operations on binary representations of data. The left shift operator (<<) shifts bits to the left, effectively multiplying the number by 2 to the power of the shift count. The right shift operator (>>) shifts bits to the right, effectively dividing the number by 2 to the power of the shift count.


#include <stdio.h>
int main() {
    int num = 10;
    printf("Value after left shifting: %d", num << 2); // Output: 40
    printf("Value after right shifting: %d", num >> 1); // Output: 5
    return 0;

5. Compound Assignment with Bitwise Operators: Efficient Code Writing

Combining compound assignment operators with bitwise operators results in efficient and compact code. These operators perform bitwise operations and assignment in a single step.


#include <stdio.h>
int main() {
    int num = 10;
    num &= 5; // Equivalent to num = num & 5;
    printf("Value after bitwise AND: %d", num); // Output: 0
    return 0;

Precedence and Associativity: Understanding Operator Priority

Operators in C have specific precedence and associativity, which determines the order of evaluation in complex expressions. Understanding these rules is essential to avoid errors and ensure the desired behavior of the program.


#include <stdio.h>
int main() {
    int result = 10 + 5 * 2; // Here, the multiplication has higher precedence.
    printf("Result: %d", result); // Output: 20
    return 0;

C Operator Precedence Table

To summarize the precedence and associativity of operators, refer to the following table:

() [ ] -> .HighestLeft to Right
! ~ ++ — + – * &
* / %Left to Right
+ –
<< >>
< <= > >=
== !=
&&Left to Right
= += -= *= /= %=Right to Left
<<= >>=
&= ^= |=
,LowestLeft to Right

Tips for Effective Use of Operators in C

Operators in C are powerful tools, but they must be used judiciously to ensure clean, efficient code. Here are some tips for effectively leveraging operators in C programming:

  1. Code Readability: Prioritize code readability over conciseness. While using complex expressions might save a few lines, it can hinder code comprehension and maintenance.
  2. Parentheses for Clarity: Use parentheses to group expressions and explicitly define the order of evaluation. This practice enhances code clarity and reduces the likelihood of errors.
  3. Avoid Undefined Behavior: Be mindful of potential undefined behaviors due to division by zero or shifting beyond the size of data types.
  4. Use Comments: When dealing with complex operations or bitwise manipulations, add comments to explain the purpose and process.
  5. Performance Considerations: Although C operators are efficient, don’t over-optimize prematurely. Focus on writing clear, correct code, and optimize later if necessary.
  6. Understand Operator Precedence: Knowing the precedence of operators helps avoid unwanted side effects and ensures the desired outcome.
  7. Testing and Debugging: Always test your code thoroughly and debug any issues that arise. Operators can sometimes introduce subtle bugs, so careful testing is essential.


  1. What are Operators in C? Operators in C are symbols or keywords used to perform various operations on data, such as arithmetic calculations, comparisons, logical decisions, bitwise manipulations, and more.
  2. Which operator is used to perform division in C? The division operator (/) is used to perform division in C. It divides the value on the left by the value on the right.
  3. What are the logical operators in C? The logical operators in C are && (logical AND), || (logical OR), and ! (logical NOT). They are used to create compound conditions for decision-making.
  4. Can you provide an example of the ternary operator in C? Certainly! Here’s an example of the ternary operator:
#include <stdio.h>
int main() {
    int num = 10;
    int result = (num > 5) ? num : 5;
    printf("Result: %d", result); // Output: 10 (since num > 5 is true)
    return 0;
  1. Why are bitwise operators used in C? Bitwise operators are used in C for low-level data manipulation, memory optimization, and handling flags or settings that involve individual bits.
  2. How can I avoid common errors with C operators? To avoid common errors, always double-check the precedence and associativity of operators when using them in complex expressions. Additionally, test your code thoroughly to catch any bugs early on.