Operators and Expressions in C

Operators and expressions form the backbone of computation in C programming. Operators perform operations on variables and constants, while expressions combine operators and operands to produce values. Understanding these is crucial for writing efficient, readable, and maintainable code.

1. Arithmetic Operators

Arithmetic operators in C allow you to perform basic mathematical operations such as addition, subtraction, multiplication, division, and modulus. They are fundamental for calculations and numeric manipulations.

Addition (+): Adds two operands. Example: int sum = a + b;
Subtraction (-): Subtracts the second operand from the first. Example: int diff = a - b;
Multiplication (*): Multiplies operands. Example: int prod = a * b;
Division (/): Divides the numerator by the denominator. Example: int div = a / b;
Modulus (%): Returns remainder after division. Example: int rem = a % b;

Common mistakes: dividing by zero, integer division truncation. Use proper casting to get floating-point results when necessary.

2. Assignment Operators

Assignment operators assign values to variables. The simplest is '=', but C provides compound assignment operators that combine arithmetic operations with assignment.

Basic assignment: a = 10;
Addition assignment: a += 5; // equivalent to a = a + 5;
Subtraction assignment: a -= 3; // equivalent to a = a - 3;
Multiplication assignment: a *= 2; // equivalent to a = a * 2;
Division assignment: a /= 5; // equivalent to a = a / 5;
Modulus assignment: a %= 3; // equivalent to a = a % 3;

3. Increment/Decrement Operators

Increment (++) and decrement (--) operators increase or decrease a variable's value by one. They can be used in prefix or postfix form, affecting the evaluation order.

Prefix increment: ++a; // increments first, then evaluates
Postfix increment: a++; // evaluates first, then increments
Prefix decrement: --a; // decrements first, then evaluates
Postfix decrement: a--; // evaluates first, then decrements
Common use: loops and counters.

4. Relational Operators

Relational operators compare two values and return either true (1) or false (0). They are often used in conditions and loops.

Equal to (==): a == b;
Not equal to (!=): a != b;
Greater than (>): a > b;
Less than (<): a < b;
Greater than or equal to (>=): a >= b;
Less than or equal to (<=): a <= b;

5. Logical Operators

Logical operators combine relational or boolean expressions. They are crucial in decision making and complex condition evaluation.

Logical AND (&&): true if both operands are true. Example: (a > 0 && b > 0);
Logical OR (||): true if at least one operand is true. Example: (a > 0 || b > 0);
Logical NOT (!): negates a boolean expression. Example: !(a > 0);

6. Conditional (Ternary) Operator

The conditional operator is a shorthand for if-else statements. Syntax: condition ? expression_if_true : expression_if_false;

Example: int max = (a > b) ? a : b;
Used for simple conditional assignments to improve code brevity.

7. Sizeof Operator

The sizeof operator returns the memory size (in bytes) of a variable or data type.

Example: int x; printf("%zu", sizeof(x));
Example: printf("%zu", sizeof(int));
Useful for memory management and dynamic allocations.

8. Comma Operator

The comma operator allows multiple expressions to be evaluated in sequence, with the last expression's value returned.

Example: int x = (a = 1, b = 2, a + b);
Commonly used in for loop expressions.

9. Bitwise Operators

Bitwise operators perform operations on individual bits of integer types.

AND (&): a & b;
OR (|): a | b;
XOR (^): a ^ b;
NOT (~): ~a;
Left shift (<<): a << 2;
Right shift (>>): a >> 2;

10. Expression

An expression is a combination of operators and operands that produces a value. Expressions can be simple or complex and are the building blocks of statements in C.

Examples: a + b, x * y - z, func(a, b)
Expression statements: expressions followed by semicolon: x = a + b;

11. Type Conversion

Type conversion changes the type of a variable or expression. C supports implicit (automatic) and explicit (casting) conversions.

Implicit conversion: int a = 5; float b = a; // int converted to float automatically
Explicit conversion: float b = (float)a;
Used to prevent data loss or match types in expressions.

12. Precedence and Associativity of Operators

Operator precedence determines which operator is evaluated first in an expression. Associativity determines the order of evaluation for operators with the same precedence.

Example: a + b * c; // multiplication evaluated before addition
Example: a = b = c; // right-to-left associativity for assignment
Refer to a C operator precedence table for detailed rules.

Conclusion

Understanding operators and expressions is essential for mastering C programming. Operators allow you to perform calculations, make decisions, manipulate bits, and control program flow. Expressions combine these operators and operands to produce results. Proper use of operator precedence, type conversion, and expression evaluation ensures correct and efficient programs.