Operator Classification in C

The C programming language provides a comprehensive set of operators, which can be categorized based on thier functionality and operand count. The primary categories include:

• Arithmetic: +, -, *, /, %
• Shift: <<, >>
• Bitwise: &, |, ^, ~
• Assignment: =, +=, -=, *=, /=, %=, <<=, >>=, &=, |=, ^=
• Unary: !, ++, --, &, *, +, -, ~, sizeof
• Relational: >, >=, <, <=, ==, !=
• Logical: &&, ||
• Conditional: ?:
• Comma: ,
• Subscript: []
• Function Call: ()

Number Bases and Conversion Fundamentals

Computers process data in binary, but developers frequent work with decimal, octal, and hexadecimal representations for readability. Each base uses a specific positional weighting system.

Decimal to Binary Conversion: Repeatedly divide the number by 2 and record the remainders. Reading the remainders from bottom to top yields the binary sequence. For example, the decimal value 120 becomes 1111000 in binary.

Binary to Octal/Hexadecimal: Group binary digits from right to left. Octal uses groups of 3 bits (0-7), while hexadecimal uses groups of 4 bits (0-9, A-F). Leading zeros are padded if the final group is incomplete.

Source code literals reflect these bases through specific prefixes:

#include <stdio.h>

int main(void) {
    int base_10 = 42;
    int base_8  = 052;
    int base_16 = 0x2A;
    
    printf("Decimal: %d\n", base_10);
    printf("Octal: %d\n", base_8);
    printf("Hex: %d\n", base_16);
    return 0;
}

Note the leading 0 for octal and 0x for hexadecimal. Omitting these prefixes forces the compiler to interpret the literal as decimal.

Integer Encoding: Sign-Magnitude, One's Complement, and Two's Complement

For signed integers, C implementations typically utilize three binary representations. The most significant bit (MSB) serves as the sign flag: 0 for positive, 1 for negative.

• Sign-Magnitude (Original Code): Direct translation of the absolute value into binary, with the MSB set according to the sign.
• One's Complement: Inverts all bits of the sign-magnitude representation, preserving the sign bit.
• Two's Complement: Adds 1 to the one's complement. This is the standard representation for storage and arithmetic in modern CPUs.

Positive numbers share identical representations across all three formats. Negative numbers differ. The hardware preference for two's complement stems from its ability to unify sign handling and simplify arithmetic logic, allowing subtraction to be performed as addition without additional circuitry.

#include <stdio.h>

int main(void) {
    int target = -14;
    // 32-bit layout (assuming two's complement)
    // Sign-Magnitude:  10000000 00000000 00000000 00001110
    // One's Complement: 11111111 11111111 11111111 11110001
    // Two's Complement: 11111111 11111111 11111111 11110010
    printf("Value in hex: 0x%x\n", target);
    printf("Value in dec: %d\n", target);
    return 0;
}

While memory stores two's complement, format specifiers like %d interpret the bit pattern back into a human-readable decimal form.

Bit Shifting Operations

Shift operators manipulate the binary representation of integers by moving bits left or right. They exclusively operate on integer types.

Left Shift (<<): Shifts bits to the left. The leftmost bits are discarded, and zeros fill the vacated positions on the right. This operation effectively multiplies the operand by powers of two.

#include <stdio.h>

int main(void) {
    int payload = 25;
    int shifted_left = payload << 2;
    printf("25 << 2 = %d\n", shifted_left); // Outputs 100
    return 0;
}

Right Shift (>>): Shifts bits to the right. The behavior of the newly introduced MSBs depends on the implemantation:

• Logical Shift: Fills MSBs with zeros. This can inadvertently change the sign of negative numbers.
• Arithmetic Shift: Fills MSBs with the original sign bit, preserving the number's sign. This is the most common behavior for signed integers.

The C standard leaves the choice between logical and arithmetic right shifts for signed integers as implementation-defined. Most modern compilers default to arithmetic shifting for signed types.

#include <stdio.h>

int main(void) {
    int negative_val = -16;
    int shifted_right = negative_val >> 3;
    printf("-16 >> 3 = %d\n", shifted_right); // Typically outputs -2
    return 0;
}

Bitwise Logical Operators

Bitwise operators perform logical calculations on corresponding bits of integer operands. Like shifts, they require integer inputs.

Bitwise AND (&): Results in 1 only when both corresponding bits are 1.

#include <stdio.h>

int main(void) {
    int operand_x = 18;  // 00010010
    int operand_y = 12;  // 00001100
    int result_and = operand_x & operand_y; // 00000000 -> 0
    printf("Bitwise AND: %d\n", result_and);
    return 0;
}

Bitwise OR (|): Results in 1 if at least one corresponding bit is 1.

#include <stdio.h>

int main(void) {
    int val_a = 18;  // 00010010
    int val_b = 12;  // 00001100
    int result_or = val_a | val_b; // 00011110 -> 30
    printf("Bitwise OR: %d\n", result_or);
    return 0;
}

Bitwise XOR (^): Results in 1 when corresponding bits differ, and 0 when they match.

#include <stdio.h>

int main(void) {
    int num_1 = 18;  // 00010010
    int num_2 = 12;  // 00001100
    int result_xor = num_1 ^ num_2; // 00011110 -> 30
    printf("Bitwise XOR: %d\n", result_xor);
    return 0;
}

Bitwise NOT (~): Inverts every bit in the operand (0 becomes 1, 1 becomes 0). In two's complement systems, this is mathematically equivalent to -(x + 1).

#include <stdio.h>

int main(void) {
    int source = 20;
    int inverted = ~source;
    printf("Bitwise NOT of 20: %d\n", inverted); // Outputs -21
    return 0;
}