1. Arithmetic Operators

Arithmetic operators are used to perform common mathematical operations on numerical values (operands). The basic arithmetic operators are:

• + (Addition)
• - (Subtraction)
• * (Multiplication)
• / (Division)
• % (Modulus)
• ++ (Increment)
• -- (Decrement)

Example: Using Arithmetic Operators

#include <stdio.h>

int main() {
    int a = 10, b = 3;
    int sum = a + b;
    int diff = a - b;
    int prod = a * b;
    int quotient = a / b;
    int remainder = a % b;
    a++; // Increment a by 1
    b--; // Decrement b by 1

    printf("Sum: %d\n", sum);
    printf("Difference: %d\n", diff);
    printf("Product: %d\n", prod);
    printf("Quotient: %d\n", quotient);
    printf("Remainder: %d\n", remainder);
    printf("Incremented a: %d\n", a);
    printf("Decremented b: %d\n", b);

    return 0;
}

Sum: 13
Difference: 7
Product: 30
Quotient: 3
Remainder: 1
Incremented a: 11
Decremented b: 2
                

2. Assignment Operators

Assignment operators are used to assign values to variables. The most basic is the = operator, but there are compound assignment operators that combine arithmetic operations with assignment.

Compound assignment operators include:

• += (Add and assign)
• -= (Subtract and assign)
• *= (Multiply and assign)
• /= (Divide and assign)
• %= (Modulus and assign)

Example: Using Assignment Operators

#include <stdio.h>

int main() {
    int x = 5;
    x += 3; // Equivalent to x = x + 3
    printf("x after += 3: %d\n", x);
    x -= 2; // Equivalent to x = x - 2
    printf("x after -= 2: %d\n", x);
    x *= 4; // Equivalent to x = x * 4
    printf("x after *= 4: %d\n", x);
    x /= 2; // Equivalent to x = x / 2
    printf("x after /= 2: %d\n", x);
    x %= 3; // Equivalent to x = x % 3
    printf("x after %= 3: %d\n", x);

    return 0;
}

x after += 3: 8
x after -= 2: 6
x after *= 4: 24
x after /= 2: 12
x after %= 3: 0
                

3. Comparison Operators

Comparison operators are used to compare two values. They return either 1 (true) or 0 (false). The comparison operators are:

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

Example: Using Comparison Operators

#include <stdio.h>

int main() {
    int a = 5, b = 10;
    printf("a == b: %d\n", a == b);
    printf("a != b: %d\n", a != b);
    printf("a < b: %d\n", a < b);
    printf("a > b: %d\n", a > b);
    printf("a <= b: %d\n", a <= b);
    printf("a >= b: %d\n", a >= b);

    return 0;
}

a == b: 0
a != b: 1
a < b: 1
a > b: 0
a <= b: 1
a >= b: 0
                

4. Logical Operators

Logical operators are used to combine conditional statements. They are:

• && (Logical AND)
• || (Logical OR)
• ! (Logical NOT)

Example: Using Logical Operators

#include <stdio.h>

int main() {
    int a = 5, b = 10, c = 5;
    printf("(a == b) && (a == c): %d\n", (a == b) && (a == c));
    printf("(a == b) || (a == c): %d\n", (a == b) || (a == c));
    printf("!(a == b): %d\n", !(a == b));

    return 0;
}

(a == b) && (a == c): 0
(a == b) || (a == c): 1
!(a == b): 1
                

5. Bitwise Operators

Bitwise operators perform operations on the binary representations of integers. They include:

• & (Bitwise AND)
• | (Bitwise OR)
• ^ (Bitwise XOR)
• ~ (Bitwise NOT)
• << (Left Shift)
• >> (Right Shift)

Example: Using Bitwise Operators

#include <stdio.h>

int main() {
    unsigned char a = 5;      // 00000101 in binary
    unsigned char b = 9;      // 00001001 in binary

    printf("a & b: %d\n", a & b); // Bitwise AND
    printf("a | b: %d\n", a | b); // Bitwise OR
    printf("a ^ b: %d\n", a ^ b); // Bitwise XOR
    printf("~a: %d\n", ~a);       // Bitwise NOT
    printf("b << 1: %d\n", b << 1); // Left Shift
    printf("b >> 1: %d\n", b >> 1); // Right Shift

    return 0;
}

a & b: 1
a | b: 13
a ^ b: 12
~a: -6
b << 1: 18
b >> 1: 4
                

6. Other Operators

Other important operators in C include:

• Conditional (Ternary) Operator: condition ? expression1 : expression2
• Sizeof Operator: sizeof(type) or sizeof(variable)
• Comma Operator: , used to separate expressions
• Member Access Operators: . and -> used with structures and pointers

Example: Using the Conditional Operator

#include <stdio.h>

int main() {
    int a = 10, b = 20;
    int max = (a > b) ? a : b;
    printf("Maximum value: %d\n", max);
    return 0;
}

Example: Using the sizeof Operator

#include <stdio.h>

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

Best Practices

• Use parentheses to make the order of operations explicit and improve code readability.
• Be cautious with operator precedence; when in doubt, use parentheses.
• Use compound assignment operators to make code concise.
• Ensure variables are initialized before using them in expressions.
• When using bitwise operators, ensure you understand how they manipulate bits.

Don'ts

• Don't mix data types in operations without explicit casting.
• Don't rely on implicit type conversion, which can lead to unexpected results.
• Don't ignore operator precedence; this can cause logical errors in expressions.
• Don't perform division by zero; it leads to undefined behavior.
• Don't forget that the increment/decrement operators can have postfix and prefix forms, which behave differently in expressions.

Key Takeaways

• Operators are essential for performing operations on variables and values in C.
• Understanding different types of operators allows you to write more efficient and effective code.
• Operator precedence determines the order in which operations are performed; use parentheses to control this order.
• Proper use of operators is crucial for avoiding logical errors in programs.