C Programming Operators Arithmetic Relational Logical Bitwise Assignment Complete Guide

1. Arithmetic Operators

Description: Arithmetic operators are used to perform mathematical operations like addition, subtraction, multiplication, division, and modulus on integer or floating-point numbers.

Operators:

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

Example:

#include <stdio.h>

int main() {
    int a = 10, b = 2, result;

    // Addition
    result = a + b;
    printf("Addition: %d\n", result);

    // Subtraction
    result = a - b;
    printf("Subtraction: %d\n", result);

    // Multiplication
    result = a * b;
    printf("Multiplication: %d\n", result);

    // Division (integer)
    result = a / b;
    printf("Division: %d\n", result);

    // Modulus (remainder)
    result = a % b;
    printf("Modulus: %d\n", result);

    // Increment
    int x = 5;
    printf("Before increment: %d\n", x);
    x++;
    printf("After increment: %d\n", x);

    // Decrement
    printf("Before decrement: %d\n", x);
    x--;
    printf("After decrement: %d\n", x);

    return 0;
}

Step-by-Step Explanation:

1. We declare two integer variables a and b and initialize them to 10 and 2 respectively.
2. For each arithmetic operation, we compute the result and store it in the variable result.
3. We use the printf function to print the results to the console.
4. We also demonstrate the pre-increment and post-increment (and similarly for decrement) on the variable x.

Output:

Addition: 12
Subtraction: 8
Multiplication: 20
Division: 5
Modulus: 0
Before increment: 5
After increment: 6
Before decrement: 6
After decrement: 5

2. Relational Operators

Description: Relational operators are used to compare two values and yield a Boolean result (true or false, represented as 1 or 0 in C).

Operators:

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

Example:

#include <stdio.h>

int main() {
    int num1 = 10, num2 = 5;

    printf("%d > %d is %d\n", num1, num2, (num1 > num2));
    printf("%d < %d is %d\n", num1, num2, (num1 < num2));
    printf("%d >= %d is %d\n", num1, num2, (num1 >= num2));
    printf("%d <= %d is %d\n", num1, num2, (num1 <= num2));
    printf("%d == %d is %d\n", num1, num2, (num1 == num2));
    printf("%d != %d is %d\n", num1, num2, (num1 != num2));

    return 0;
}

Step-by-Step Explanation:

1. We declare two integer variables num1 and num2 and assign them values.
2. We use each relational operator to compare num1 and num2.
3. The expression inside the printf evaluates to either 0 or 1, representing false or true, respectively.

Output:

10 > 5 is 1
10 < 5 is 0
10 >= 5 is 1
10 <= 5 is 0
10 == 5 is 0
10 != 5 is 1

3. Logical Operators

Description: Logical operators are used to combine two or more conditions and yield a Boolean result. They are mainly used in if statements and loops to make decision-making easier.

Operators:

• && Logical AND (both conditions must be true for the result to be true)
• || Logical OR (at least one condition must be true for the result to be true)
• ! Logical NOT (it inverts the result; if the condition is true, ! makes it false)

Example:

#include <stdio.h>

int main() {
    int p = 1, q = 0; // Assume 1=true, 0=false

    // Logical AND
    printf("p && q = %d\n", (p && q));

    // Logical OR
    printf("p || q = %d\n", (p || q));

    // Logical NOT
    printf("!q = %d\n", (!q));

    return 0;
}

Step-by-Step Explanation:

1. We define two variables p and q and initialize them to 1 and 0 (representing true and false).
2. We use logical operators to combine the conditions formed by p and q.
3. The results are printed out where 1 means true and 0 means false.

Output:

p && q = 0
p || q = 1
!q = 1

4. Bitwise Operators

Description: Bitwise operators manipulate bits directly. They can be used for low-level programming, such as bit masking, hardware interfacing, etc.

Operators:

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

Example:

#include <stdio.h>

int main() {
    unsigned int a = 25;  // Binary: 11001
    unsigned int b = 17;  // Binary: 10001
    int result;

    // Bitwise AND
    result = a & b;
    printf("a & b = %d\n", result); 

    // Bitwise OR
    result = a | b;
    printf("a | b = %d\n", result);

    // Bitwise XOR
    result = a ^ b;
    printf("a ^ b = %d\n", result);

    // Bitwise NOT
    result = ~a;
    printf("~a = %u\n", result); 

    // Bitwise Left Shift
    result = a << 1;
    printf("a << 1 = %d\n", result);

    // Bitwise Right Shift
    result = a >> 1;
    printf("a >> 1 = %d\n", result);

    return 0;
}

Step-by-Step Explanation:

1. We take two unsigned integers a and b, whose binary equivalents are provided in comments.
2. Each bitwise operation is performed using the respective operator on a and b.
3. The results are stored in the variable result and then printed out.
4. Note that for bitwise NOT operation, we use %u format specifier instead of %d because the result is an unsigned number.

Output:

a & b = 17
a | b = 29
a ^ b = 12
~a = 4294967268
a << 1 = 50
a >> 1 = 12

Note: The output 4294967268 for ~a is due to the fact that the NOT operation flips all bits, including the sign bit for the unsigned integer, resulting in a large positive number.

5. Assignment Operators

Description: Assignment operators are used to assign a value to a variable. Simple assignment is =, but there are compound assignment operators available which first perform the arithmetic operation, then the assignment.

Operators:

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

Example:

#include <stdio.h>

int main() {
    int x = 5, y;

    // Simple Assignment
    y = x;
    printf("y = %d\n", y);

    // Add and Assign
    x += 3; // Equivalent to x = x + 3
    printf("x += 3: %d\n", x);

    // Subtract and Assign
    x -= 2; // Equivalent to x = x - 2
    printf("x -= 2: %d\n", x);

    // Multiply and Assign
    x *= 2; // Equivalent to x = x * 2
    printf("x *= 2: %d\n", x);

    // Divide and Assign
    x /= 4; // Equivalent to x = x / 4
    printf("x /= 4: %d\n", x);

    // Modulus and Assign
    x %= 3; // Equivalent to x = x % 3
    printf("x %%= 3: %d\n", x);

    return 0;
}

Step-by-Step Explanation:

1. We declare and initialize an integer variable x with the value 5.
2. We perform simple assignment of x to another variable y and print y.
3. Using compound assignment operators, we modify the value of x and print the results at each step:
   • += adds the value on the right and assigns it to the left
   • -= subtracts the value on the right from the left and assigns it to the left
   • *= multiplies the value on the left by the value on the right and assigns it to the left
   • /= divides the left operand by the right operand and assigns the quotient to the left operand
   • %= takes the modulus using two operands and assigns the result to the left operand

Output: