C programming is a foundational language that provides the building blocks for many modern programming languages. One of the critical elements in C programming is the use of operators. In this article, we will explore how operators work in C. We’ll break down the different types of operators, how they function, and provide examples to illustrate their usage.
For those preparing for technical interviews, understanding operators in C is crucial. Additionally, if you’re looking for common C interview questions, it’s beneficial to familiarize yourself with these concepts early on.
Introduction to Operators in C
Operators are special symbols or keywords that take one or more operands and perform a specific operation. They are an integral part of any programming language, and understanding them is crucial for writing efficient and effective code. In C, operators are categorized based on the number of operands they take and the type of operations they perform.
Types of Operators in C
C provides a rich set of operators, which can be classified into the following types:

Arithmetic Operators

Relational Operators

Logical Operators

Bitwise Operators

Assignment Operators

Increment and Decrement Operators

Conditional (Ternary) Operator

Special Operators
Let’s dive deeper into each category to understand how they work.
Arithmetic Operators in C
Arithmetic operators are used to perform basic mathematical operations such as addition, subtraction, multiplication, division, and modulus.
Addition (+) and Subtraction () Operators
The addition operator (+) adds two operands, while the subtraction operator (–) subtracts the second operand from the first.
Example:
c
Copy code
int a = 10, b = 5;
int sum = a + b; // sum = 15
int diff = a – b; // diff = 5
Multiplication (*) and Division (/) Operators
The multiplication operator (*) multiplies two operands, and the division operator (/) divides the first operand by the second.
Example:
c
Copy code
int a = 10, b = 5;
int product = a * b; // product = 50
int quotient = a / b; // quotient = 2
Modulus (%) Operator
The modulus operator (%) returns the remainder of the division of two integers.
Example:
c
Copy code
int a = 10, b = 3;
int remainder = a % b; // remainder = 1
Relational Operators in C
Relational operators compare two operands and return a boolean value (true or false) based on the comparison.
Equality (==) and Inequality (!=) Operators
The equality operator (==) checks if two operands are equal, while the inequality operator (!=) checks if they are not equal.
Example:
c
Copy code
int a = 10, b = 5;
bool isEqual = (a == b); // isEqual = false
bool isNotEqual = (a != b); // isNotEqual = true
Greater Than (>) and Less Than (<) Operators
The greater than operator (>) checks if the first operand is greater than the second, while the less than operator (<) checks if the first operand is less than the second.
Example:
c
Copy code
int a = 10, b = 5;
bool isGreater = (a > b); // isGreater = true
bool isLess = (a < b); // isLess = false
Greater Than or Equal To (>=) and Less Than or Equal To (<=) Operators
The greater than or equal to operator (>=) checks if the first operand is greater than or equal to the second, while the less than or equal to operator (<=) checks if the first operand is less than or equal to the second.
Example:
c
Copy code
int a = 10, b = 5;
bool isGreaterOrEqual = (a >= b); // isGreaterOrEqual = true
bool isLessOrEqual = (a <= b); // isLessOrEqual = false
Logical Operators in C
Logical operators are used to combine multiple relational expressions and return a boolean result.
Logical AND (&&) Operator
The logical AND operator (&&) returns true if both operands are true, otherwise it returns false.
Example:
c
Copy code
int a = 10, b = 5;
bool result = (a > b) && (a != b); // result = true
Logical OR () Operator
The logical OR operator () returns true if at least one of the operands is true.
Example:
c
Copy code
int a = 10, b = 5;
bool result = (a > b)  (a == b); // result = true
Logical NOT (!) Operator
The logical NOT operator (!) inverts the boolean value of its operand.
Example:
c
Copy code
int a = 10, b = 5;
bool result = !(a < b); // result = true
Bitwise Operators in C
Bitwise operators perform operations on the binary representations of integers.
Bitwise AND (&) Operator
The bitwise AND operator (&) performs a bitwise AND operation on the corresponding bits of its operands.
Example:
c
Copy code
int a = 5; // 0101 in binary
int b = 3; // 0011 in binary
int result = a & b; // result = 1 (0001 in binary)
Bitwise OR () Operator
The bitwise OR operator () performs a bitwise OR operation on the corresponding bits of its operands.
Example:
c
Copy code
int a = 5; // 0101 in binary
int b = 3; // 0011 in binary
int result = a  b; // result = 7 (0111 in binary)
Bitwise XOR (^) Operator
The bitwise XOR operator (^) performs a bitwise XOR operation on the corresponding bits of its operands.
Example:
c
Copy code
int a = 5; // 0101 in binary
int b = 3; // 0011 in binary
int result = a ^ b; // result = 6 (0110 in binary)
Bitwise NOT (~) Operator
The bitwise NOT operator (~) inverts the bits of its operand.
Example:
c
Copy code
int a = 5; // 0101 in binary
int result = ~a; // result = 6 (inverts bits)
Bitwise Shift Operators
Left Shift (<<) Operator
The left shift operator (<<) shifts the bits of its first operand to the left by the number of positions specified by its second operand.
Example:
c
Copy code
int a = 5; // 0101 in binary
int result = a << 1; // result = 10 (1010 in binary)
Right Shift (>>) Operator
The right shift operator (>>) shifts the bits of its first operand to the right by the number of positions specified by its second operand.
Example:
c
Copy code
int a = 5; // 0101 in binary
int result = a >> 1; // result = 2 (0010 in binary)
Assignment Operators in C
Assignment operators are used to assign values to variables. The basic assignment operator is =, but there are compound assignment operators that combine an arithmetic operation with assignment.
Basic Assignment Operator (=)
The assignment operator (=) assigns the value of its right operand to its left operand.
Example:
c
Copy code
int a;
a = 10; // assigns 10 to a
Compound Assignment Operators
Add and Assign (+=)
The add and assign operator (+=) adds the value of its right operand to its left operand and assigns the result to the left operand.
Example:
c
Copy code
int a = 10;
a += 5; // a = a + 5, so a = 15
Subtract and Assign (=)
The subtract and assign operator (=) subtracts the value of its right operand from its left operand and assigns the result to the left operand.
Example:
c
Copy code
int a = 10;
a = 5; // a = a – 5, so a = 5
Multiply and Assign (*=)
The multiply and assign operator (*=) multiplies its left operand by its right operand and assigns the result to the left operand.
Example:
c
Copy code
int a = 10;
a *= 5; // a = a * 5, so a = 50
Divide and Assign (/=)
The divide and assign operator (/=) divides its left operand by its right operand and assigns the result to the left operand.
Example:
c
Copy code
int a = 10;
a /= 5; // a = a / 5, so a = 2
Modulus and Assign (%=)
The modulus and assign operator (%=) takes the modulus of its left operand with its right operand and assigns the result to the left operand.
Example:
c
Copy code
int a = 10;
a %= 3; // a = a % 3, so a = 1
Increment and Decrement Operators in C
Increment and decrement operators are used to increase or decrease the value of a variable by one.
Increment Operator (++)
The increment operator (++) increases the value of its operand by one. It can be used in two forms: prefix (++a) and postfix (a++).
Example:
c
Copy code
int a = 10;
++a; // a becomes 11
a++; // a becomes 12
Decrement Operator (–)
The decrement operator (—) decreases the value of its operand by one. It can also be used in two forms: prefix (–a) and postfix (a–).
Example:
c
Copy code
int a = 10;
–a; // a becomes 9
a–; // a becomes 8
Conditional (Ternary) Operator in C
The conditional operator (?:) is a shorthand for an ifelse statement. It takes three operands and returns one of two values based on a condition.
Syntax:
c
Copy code
condition ? value_if_true : value_if_false;
Example:
c
Copy code
int a = 10, b = 5;
int max = (a > b) ? a : b; // max = 10
Special Operators in C
C also includes some special operators that provide additional functionality.
Comma Operator (,)
The comma operator (,) allows multiple expressions to be evaluated in a single statement. The result of the expression is the value of the last expression.
Example:
c
Copy code
int a = (1, 2, 3); // a = 3
Sizeof Operator
The sizeof operator returns the size (in bytes) of a data type or a variable.
Example:
c
Copy code
int a = 10;
size_t size = sizeof(a); // size = 4 (assuming 4byte integers)
*Pointer Operators (& and )
The addressof operator (&) returns the address of a variable, and the dereference operator (*) returns the value at a given address.
Example:
c
Copy code
int a = 10;
int *p = &a; // p points to a
int value = *p; // value = 10
Practical Examples of Operators in C
To further understand how operators work in C, let’s look at a practical example that combines different types of operators.
Example:
c
Copy code
#include <stdio.h>
int main() {
int a = 5, b = 10, result;
// Arithmetic and assignment operators
result = a + b; // result = 15
result *= 2; // result = 30
// Relational and logical operators
if (result > 20 && result <= 30) {
printf(“Result is within range.n”);
}
// Bitwise operators
result = a & b; // result = 0 (0101 & 1010 = 0000)
result = a  b; // result = 15 (0101  1010 = 1111)
// Increment and decrement operators
a++; // a = 6
b–; // b = 9
// Conditional operator
result = (a > b) ? a : b; // result = 9
// Special operators
size_t size = sizeof(result); // size = 4 (assuming 4byte integers)
printf(“Size of result: %zu bytesn”, size);
return 0;
}
In this example, we see how various operators are used together to perform different operations and achieve a specific outcome. By understanding and mastering these operators, you can write more efficient and effective C code.
Common Mistakes and Best Practices
When working with operators in C, it’s essential to be aware of common mistakes and follow best practices to avoid errors and improve code quality.
Common Mistakes

Misusing Assignment and Equality Operators:

Mistake: Using = instead of == in conditional statements.

Fix: Ensure you use == for comparisons and = for assignments.

c
Copy code
// Incorrect:
if (a = b) { … }
// Correct:
if (a == b) { … }

Incorrect Operator Precedence:

Mistake: Assuming incorrect precedence of operators in complex expressions.

Fix: Use parentheses to explicitly define the order of operations.

c
Copy code
// Incorrect:
result = a + b * c; // result may not be as expected
// Correct:
result = (a + b) * c;

Overlooking Increment/Decrement Operator Position:

Mistake: Confusing the effect of prefix and postfix increment/decrement operators.

Fix: Be clear about whether you want the operation to occur before or after the value is used.

c
Copy code
int a = 5;
int b = a++; // b = 5, a = 6
int c = ++a; // c = 7, a = 7
Best Practices

Use Descriptive Variable Names:

Choose meaningful names for variables to make the code more readable.


Comment Complex Expressions:

Add comments to explain complex expressions and the logic behind them.


Consistent Formatting:

Follow consistent code formatting and indentation to improve readability and maintainability.


Test and Validate:

Test your code thoroughly to ensure it behaves as expected with different inputs and edge cases.

Conclusion
Understanding how operators work in C is fundamental to mastering the language. Operators allow you to perform a wide range of operations, from basic arithmetic to complex bitwise manipulations. By learning the different types of operators and their usage, you can write more efficient and powerful C programs. Remember to avoid common mistakes and follow best practices to ensure your code is robust and maintainable.