Bitwise NOT in C — Why ~ Clears Adjacent Permission Bits

#include <stdio.h>

// Helper: print an integer as 8-bit binary so we can SEE what's happening
void print_binary(const char *label, unsigned int value) {
    printf("%-20s = ", label);
    for (int bit_position = 7; bit_position >= 0; bit_position--) {
        // Shift the bit we care about all the way to position 0, then mask it
        printf("%d", (value >> bit_position) & 1);
    }
    printf(" (decimal: %u)\n", value);
}

int main(void) {
    unsigned int lights_a = 0b00110101; // switches: 6,5 and 4,2 and 0 are ON  = 53
    unsigned int lights_b = 0b00101110; // switches: 5,3,2,1 are ON            = 46

    printf("=== Starting values ===\n");
    print_binary("lights_a",         lights_a);
    print_binary("lights_b",         lights_b);

    printf("\n=== AND — both must be ON ===\n");
    // Only bits that are 1 in BOTH patterns survive
    print_binary("a & b",            lights_a & lights_b);

    printf("\n=== OR — at least one ON ===\n");
    // Any bit that is 1 in EITHER pattern survives
    print_binary("a | b",            lights_a | lights_b);

    printf("\n=== XOR — exactly one ON ===\n");
    // Bits that differ between the two patterns become 1
    print_binary("a ^ b",            lights_a ^ lights_b);

    printf("\n=== NOT — flip everything ===\n");
    // Every 0 becomes 1 and every 1 becomes 0 (we mask to 8 bits for clarity)
    print_binary("~a (8-bit masked)", (~lights_a) & 0xFF);

    printf("\n=== LEFT SHIFT — multiply by 2 per shift ===\n");
    // Shifting left by 2 is the same as multiplying by 4
    print_binary("a << 2",           (lights_a << 2) & 0xFF);

    printf("\n=== RIGHT SHIFT — divide by 2 per shift ===\n");
    // Shifting right by 1 is the same as integer division by 2
    print_binary("a >> 1",           lights_a >> 1);

    return 0;
}

#include <stdio.h>

// Define each permission as a bit flag using left shifts
// This makes the intent crystal-clear and avoids magic numbers
#define PERMISSION_READ     (1 << 0)  // bit 0 = 00000001 = 1
#define PERMISSION_WRITE    (1 << 1)  // bit 1 = 00000010 = 2
#define PERMISSION_EXECUTE  (1 << 2)  // bit 2 = 00000100 = 4
#define PERMISSION_DELETE   (1 << 3)  // bit 3 = 00001000 = 8
#define PERMISSION_SHARE    (1 << 4)  // bit 4 = 00010000 = 16

// A single byte can hold all 5 permissions — no wasted memory
typedef unsigned char PermissionSet;

void print_permissions(PermissionSet perms) {
    printf("Permissions: [%s] [%s] [%s] [%s] [%s]\n",
        (perms & PERMISSION_READ)    ? "READ"    : "----",
        (perms & PERMISSION_WRITE)   ? "WRITE"   : "-----",
        (perms & PERMISSION_EXECUTE) ? "EXECUTE" : "-------",
        (perms & PERMISSION_DELETE)  ? "DELETE"  : "------",
        (perms & PERMISSION_SHARE)   ? "SHARE"   : "-----"
    );
}

int main(void) {
    // Start with no permissions at all — a clean slate
    PermissionSet user_permissions = 0;

    printf("--- Initial state ---\n");
    print_permissions(user_permissions);

    // SET bits: grant read and write using OR
    // OR with the flag mask forces that bit to 1 without touching others
    user_permissions |= PERMISSION_READ;
    user_permissions |= PERMISSION_WRITE;
    printf("\n--- After granting READ and WRITE ---\n");
    print_permissions(user_permissions);

    // SET multiple flags at once by OR-ing them together in one line
    user_permissions |= (PERMISSION_EXECUTE | PERMISSION_SHARE);
    printf("\n--- After granting EXECUTE and SHARE ---\n");
    print_permissions(user_permissions);

    // CLEAR a bit: revoke write using AND with the inverted mask
    // ~PERMISSION_WRITE = 11111101 — forces bit 1 to 0, leaves all others
    user_permissions &= ~PERMISSION_WRITE;
    printf("\n--- After revoking WRITE ---\n");
    print_permissions(user_permissions);

    // CHECK a bit: test if the user can execute
    // AND with the flag mask — non-zero means the bit is set
    if (user_permissions & PERMISSION_EXECUTE) {
        printf("\n--- Access check: EXECUTE permission GRANTED ---\n");
    }

    // TOGGLE a bit: flip SHARE using XOR
    // XOR with 1 flips the bit; XOR with 0 leaves it unchanged
    user_permissions ^= PERMISSION_SHARE;
    printf("\n--- After toggling SHARE (was ON, now OFF) ---\n");
    print_permissions(user_permissions);

    return 0;
}

#include <stdio.h>
#include <stdint.h>  // for uint32_t, uint8_t — always use fixed-width types for bit work

// Pack four 8-bit color channels into one 32-bit unsigned integer
// Layout: [ALPHA: bits 31-24] [RED: bits 23-16] [GREEN: bits 15-8] [BLUE: bits 7-0]
uint32_t pack_rgba(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) {
    uint32_t packed = 0;
    packed |= ((uint32_t)alpha << 24); // shift alpha into the top 8 bits
    packed |= ((uint32_t)red   << 16); // shift red into bits 23-16
    packed |= ((uint32_t)green <<  8); // shift green into bits 15-8
    packed |= ((uint32_t)blue  <<  0); // blue sits in the lowest 8 bits (no shift needed)
    return packed;
}

// Unpack: shift the target field down to bit-0, then mask off everything above it
uint8_t extract_red(uint32_t packed_color) {
    return (packed_color >> 16) & 0xFF; // shift down 16, keep only lowest 8 bits
}

uint8_t extract_green(uint32_t packed_color) {
    return (packed_color >> 8) & 0xFF;  // shift down 8, keep only lowest 8 bits
}

uint8_t extract_blue(uint32_t packed_color) {
    return packed_color & 0xFF;         // blue is already at bit 0, just mask
}

uint8_t extract_alpha(uint32_t packed_color) {
    return (packed_color >> 24) & 0xFF; // shift down 24, keep only lowest 8 bits
}

// Demonstrate fast multiply/divide with shifts
void demonstrate_shift_arithmetic(void) {
    unsigned int pixel_count = 13;
    printf("\n=== Shift Arithmetic Demo ===\n");
    printf("pixel_count          = %u\n",  pixel_count);
    printf("pixel_count << 1     = %u  (x2 = multiply by 2^1)\n",  pixel_count << 1);
    printf("pixel_count << 3     = %u  (x8 = multiply by 2^3)\n",  pixel_count << 3);
    printf("pixel_count >> 1     = %u  (÷2 = divide by 2^1)\n",   pixel_count >> 1);
}

int main(void) {
    // Pack a coral-ish color: R=255, G=100, B=80, A=200
    uint8_t r = 255, g = 100, b = 80, a = 200;
    uint32_t coral = pack_rgba(r, g, b, a);

    printf("=== RGBA Color Packing Demo ===\n");
    printf("Input  — R:%3u G:%3u B:%3u A:%3u\n", r, g, b, a);
    printf("Packed — 0x%08X (decimal: %u)\n", coral, coral);

    // Now unpack and verify we get the original values back
    printf("\n=== Unpacking Back Out ===\n");
    printf("Extracted — R:%3u G:%3u B:%3u A:%3u\n",
        extract_red(coral),
        extract_green(coral),
        extract_blue(coral),
        extract_alpha(coral)
    );

    demonstrate_shift_arithmetic();

    return 0;
}

#include <stdio.h>
#include <stdint.h>

// XOR swap — brilliant to understand, don't use in real code
void xor_swap(int *value_a, int *value_b) {
    if (value_a == value_b) return;  // CRITICAL guard — same address would zero both out
    *value_a ^= *value_b;            // a now holds 'a XOR b'
    *value_b ^= *value_a;            // b now holds 'b XOR (a XOR b)' = original a
    *value_a ^= *value_b;            // a now holds '(a XOR b) XOR a' = original b
}

// XOR's inverse property: encode then decode with the same key
void demonstrate_xor_encode(void) {
    uint8_t original_byte  = 0b10110011; // 179 — our data
    uint8_t secret_key     = 0b01101010; // 106 — our key

    uint8_t encoded = original_byte ^ secret_key;  // XOR to obscure
    uint8_t decoded = encoded ^ secret_key;         // XOR again with same key to recover

    printf("=== XOR Encoding Demo ===\n");
    printf("Original : %3u (0x%02X)\n", original_byte, original_byte);
    printf("Key      : %3u (0x%02X)\n", secret_key, secret_key);
    printf("Encoded  : %3u (0x%02X)\n", encoded, encoded);
    printf("Decoded  : %3u (0x%02X) — matches original: %s\n",
        decoded, decoded, (decoded == original_byte) ? "YES" : "NO");
}

// Classic algorithm: find the one number that appears only once
// Every other number in the array appears exactly twice
// XOR-ing a number with itself gives 0; XOR-ing with 0 gives the number itself
int find_unique_element(int *readings, int count) {
    int unique = 0;
    for (int index = 0; index < count; index++) {
        unique ^= readings[index]; // pairs cancel out (N^N=0); the lone value survives
    }
    return unique;
}

int main(void) {
    // Demonstrate XOR swap
    int temperature_celsius = 37;
    int boiling_point       = 100;
    printf("Before swap: temp=%d, boiling=%d\n", temperature_celsius, boiling_point);
    xor_swap(&temperature_celsius, &boiling_point);
    printf("After swap:  temp=%d, boiling=%d\n\n", temperature_celsius, boiling_point);

    demonstrate_xor_encode();

    // Sensor readings — every reading appears twice except one faulty sensor ID
    int sensor_readings[] = {4, 7, 2, 9, 7, 4, 2}; // 9 appears only once
    int reading_count = sizeof(sensor_readings) / sizeof(sensor_readings[0]);
    int faulty_sensor = find_unique_element(sensor_readings, reading_count);
    printf("\n=== Find Unique Sensor ID ===\n");
    printf("Faulty sensor ID: %d (appears only once in the data)\n", faulty_sensor);

    return 0;
}

#include <stdio.h>

int main(void) {
    unsigned int flags = 0b00001100; // bits 2 and 3 are set
    unsigned int MASK  = 0b00000100; // bit 2

    printf("flags = 0x%X, MASK = 0x%X\n", flags, MASK);

    // WRONG: == has higher precedence than &
    if (flags & MASK == 0) {
        printf("Mistake: (flags & (MASK == 0)) is false, so this prints always\n");
    }

    // CORRECT: explicitly parenthesize
    if ((flags & MASK) != 0) {
        printf("Correct: bit 2 is set\n");
    }

    // Another common trap: mixing bitwise and logical operators without parentheses
    if (flags & MASK && 1) {
        // This is parsed as (flags & MASK) && 1
        // Which works by accident, but don't rely on it
        printf("Works but ambiguous — always parenthesize\n");
    }

    // Shift + AND: make intent clear
    unsigned int extract = (flags >> 2) & 0x0F; // extract bits 2-5
    printf("Extracted bits 2-5: 0x%X\n", extract);

    return 0;
}

// io.thecodeforge — c-cpp tutorial

#include <cstdio>
#include <cstdint>

int main() {
    uint32_t packet_header = 0x12345678;
    
    // Portable byte extraction — works on every endianness
    uint8_t b0 = (packet_header >> 24) & 0xFF;
    uint8_t b1 = (packet_header >> 16) & 0xFF;
    uint8_t b2 = (packet_header >> 8)  & 0xFF;
    uint8_t b3 = packet_header & 0xFF;
    
    printf("Portable: 0x%02X %02X %02X %02X\n", b0, b1, b2, b3);
    
    // Non-portable — union with uint8_t array
    union {
        uint32_t u32;
        uint8_t  bytes[4];
    } hack;
    hack.u32 = packet_header;
    
    printf("Union:    0x%02X %02X %02X %02X\n", 
           hack.bytes[0], hack.bytes[1], 
           hack.bytes[2], hack.bytes[3]);
    return 0;
}

// io.thecodeforge — c-cpp tutorial

#include <cstdio>
#include <cstdint>
#include <climits>

int main() {
    int8_t  signed_val = -1;
    uint8_t unsigned_val = 0xFF;
    
    // Right shift on signed — implementation-defined
    printf("Signed   >> 4: %d\n", signed_val >> 4);
    printf("Unsigned >> 4: %u\n", unsigned_val >> 4);
    
    // UB: shift too far
    int32_t x = 1;
    // printf("%d\n", x << 33);  // UB. Do not uncomment.
    
    // Safe: mask before shift
    uint32_t status = 0x80000000;
    uint32_t bit_31 = (status >> 31) & 1U;  // Always 1, defined behaviour
    printf("Bit 31: %u\n", bit_31);
    
    return 0;
}

// io.thecodeforge — c-cpp tutorial
#include <stdint.h>
#include <stdio.h>

int main() {
    uint8_t flags = 0b10101100; // flags
    uint8_t mask  = 0b00001111; // mask lower nibble

    // Correct syntax: parenthesize bitwise in condition
    if ((flags & mask) != 0) {
        printf("Lower nibble has bits set\n");
    }

    // Compound assignment
    flags |= 0b00000011; // set bits 0-1
    printf("flags = 0x%02X\n", flags);

    // Warning: ~ on signed
    int x = 0;
    unsigned int y = ~0U;
    printf("~0 = %d, ~0U = %u\n", ~x, y);
    return 0;
}

// io.thecodeforge — c-cpp tutorial
#include <stdint.h>
#include <stdio.h>

int main() {
    // 1. Toggle permission bit (use unsigned) 
    uint16_t perms = 0b11011010;
    perms ^= 1u << 4;          // toggle bit 4
    printf("perms after toggle: 0x%04X\n", perms);

    // 2. Pack two 16-bit into 32-bit
    uint32_t header = (18u << 16) | 200u;
    printf("packed: 0x%08X\n", header); // 0x001200C8

    // 3. XOR swap (watch aliasing!)
    uint32_t a = 5, b = 3;
    a ^= b; b ^= a; a ^= b;
    printf("swap: %u, %u\n", a, b);

    // 4. Clear lowest set bit (Brian Kernighan)
    uint32_t v = 40; // 101000
    v &= v - 1;
    printf("clear LSB: %u\n", v); // 32 (100000)
    return 0;
}