Bits and Bytes

Bits and Bytes

This section covers bitwise operations, bit manipulation techniques, endianness, bit fields, and low-level data representation in C programming. Mastering these concepts is essential for systems programming, embedded systems, and performance optimization.

1. What are bitwise operators in C? Explain each with an example.

Answer: Bitwise operators perform operations on individual bits of integer operands. They are fundamental for low-level programming, device drivers, and optimizing certain algorithms.

• & (AND): Sets each bit to 1 if both corresponding bits are 1.
• | (OR): Sets each bit to 1 if at least one of the corresponding bits is 1.
• ^ (XOR): Sets each bit to 1 if exactly one of the corresponding bits is 1.
• ~ (NOT/Complement): Inverts all bits (1 becomes 0, 0 becomes 1).
• << (Left Shift): Shifts bits to the left, filling with 0s. Equivalent to multiplying by powers of 2.
• >> (Right Shift): Shifts bits to the right. For unsigned numbers, fills with 0s (logical shift). For signed numbers, behavior is implementation-dependent (usually arithmetic shift preserving sign bit).

#include <stdio.h>
void printBinary(unsigned int num) {
// Helper function to display bits
for (int i = 31; i >= 0; i--) {
printf("%d", (num >> i) & 1);
if (i % 8 == 0) printf(" ");
}
printf("\n");
}

int main() {
unsigned int a = 12; // Binary: 1100
unsigned int b = 10; // Binary: 1010


printf("a = 12 (decimal)  - Binary: ");
printBinary(a);
printf("b = 10 (decimal)  - Binary: ");
printBinary(b);

printf("\nBitwise Operations:\n");
printf("a & b  = %2d (AND)   - Binary: ", a & b);
printBinary(a & b);     // 1000 (8)

printf("a | b  = %2d (OR)    - Binary: ", a | b);
printBinary(a | b);     // 1110 (14)

printf("a ^ b  = %2d (XOR)   - Binary: ", a ^ b);
printBinary(a ^ b);     // 0110 (6)

printf("~a     = %2d (NOT)   - Binary: ", ~a);
printBinary(~a);        // Inverts all bits (large number)

printf("a << 1 = %2d (Left Shift)  - Binary: ", a << 1);
printBinary(a << 1);    // 11000 (24)

printf("a >> 1 = %2d (Right Shift) - Binary: ", a >> 1);
printBinary(a >> 1);    // 0110 (6)

return 0;
}

2. Write macros to set, clear, toggle, and check a specific bit in an integer.

Answer: This is a common interview question for embedded systems and low-level programming. These macros operate on a variable and a bit position (0-indexed from LSB).

#include <stdio.h> 
#include <stdint.h>
// Macros for bit manipulation
#define SET_BIT(value, bit_pos) ((value) |= (1U << (bit_pos)))
#define CLEAR_BIT(value, bit_pos) ((value) &= ~(1U << (bit_pos)))
#define TOGGLE_BIT(value, bit_pos) ((value) ^= (1U << (bit_pos)))
#define CHECK_BIT(value, bit_pos) (((value) >> (bit_pos)) & 1U)

void printBinary(uint8_t num) {
for (int i = 7; i >= 0; i--) {
printf("%d", (num >> i) & 1);
}
}

int main() {
uint8_t flags = 0; // Binary: 0000 0000


printf("Initial value:      ");
printBinary(flags);
printf(" (%d)\n", flags);

SET_BIT(flags, 2);   // Set bit 2
printf("After SET bit 2:    ");
printBinary(flags);
printf(" (%d)\n", flags);  // 0000 0100 (4)

SET_BIT(flags, 5);   // Set bit 5
printf("After SET bit 5:    ");
printBinary(flags);
printf(" (%d)\n", flags);  // 0010 0100 (36)

CLEAR_BIT(flags, 2); // Clear bit 2
printf("After CLEAR bit 2:  ");
printBinary(flags);
printf(" (%d)\n", flags);  // 0010 0000 (32)

TOGGLE_BIT(flags, 3); // Toggle bit 3
printf("After TOGGLE bit 3: ");
printBinary(flags);
printf(" (%d)\n", flags);  // 0010 1000 (40)

TOGGLE_BIT(flags, 3); // Toggle bit 3 again
printf("After TOGGLE bit 3: ");
printBinary(flags);
printf(" (%d)\n", flags);  // 0010 0000 (32)

printf("Bit 5 is: %d\n", CHECK_BIT(flags, 5));  // 1
printf("Bit 0 is: %d\n", CHECK_BIT(flags, 0));  // 0

return 0;
}

3. Write a function to swap two numbers without using a temporary variable.

Answer: This classic problem can be solved using bitwise XOR, which has the property that x ^ y ^ y = x. This method works for integers and avoids overflow issues that arithmetic methods might have.

#include <stdio.h>
void swapUsingXOR(int *a, int *b) {
if (a == b) return; // Check if same memory location


*a = *a ^ *b;
*b = *a ^ *b;
*a = *a ^ *b;
}

void swapUsingArithmetic(int *a, int *b) {
if (a == b) return;

text
*a = *a + *b;
*b = *a - *b;
*a = *a - *b;
// Note: This method can overflow for large integers
}

int main() {
int x = 42, y = 73;


printf("Original: x = %d, y = %d\n", x, y);

swapUsingXOR(&x, &y);
printf("After XOR swap: x = %d, y = %d\n", x, y);

swapUsingArithmetic(&x, &y);
printf("After arithmetic swap: x = %d, y = %d\n", x, y);

// Edge case demonstration
int a = 5, b = 5;
printf("\nSame values: a = %d, b = %d\n", a, b);
swapUsingXOR(&a, &b);
printf("After XOR swap (same values): a = %d, b = %d\n", a, b);

// Self-swap demonstration
int c = 100;
printf("\nSelf-swap: c = %d\n", c);
swapUsingXOR(&c, &c);
printf("After self-swap: c = %d\n", c); // Should remain 100 due to check

return 0;
}

4. Check if a given integer is a power of 2 using bitwise operations.

Answer: A number is a power of 2 if it has exactly one bit set in its binary representation. The trick (n & (n - 1)) == 0 works because subtracting 1 flips all bits after the rightmost set bit.

#include <stdio.h> 
#include <stdbool.h>
bool isPowerOfTwo(int n) {
// A number is power of 2 if it's positive and has exactly one bit set
return (n > 0) && ((n & (n - 1)) == 0);
}

// Alternative method: count set bits
int countSetBits(int n) {
int count = 0;
while (n) {
count += n & 1;
n >>= 1;
}
return count;
}

bool isPowerOfTwoAlt(int n) {
return (n > 0) && (countSetBits(n) == 1);
}

void printBinary(unsigned int num) {
for (int i = 31; i >= 0; i--) {
if (i == 31 || i == 23 || i == 15 || i == 7) printf(" ");
printf("%d", (num >> i) & 1);
}
}

int main() {
int testNumbers[] = {0, 1, 2, 3, 4, 5, 8, 16, 24, 32, 64, 100, 128, 255, 256};
int size = sizeof(testNumbers) / sizeof(testNumbers[0]);


printf("Number\tBinary\t\t\t\tPower of 2?\n");
printf("------\t------\t\t\t\t-----------\n");

for (int i = 0; i < size; i++) {
    int n = testNumbers[i];
    printf("%d\t", n);
    printBinary(n);
    printf("\t%s\n", isPowerOfTwo(n) ? "Yes" : "No");
}

// Demonstration of how the trick works
printf("\nHow it works:\n");
int n = 16; // 10000 in binary
printf("n     = %d (binary: ", n);
printBinary(n);
printf(")\n");
printf("n-1   = %d (binary: ", n-1);
printBinary(n-1);
printf(")\n");
printf("n & (n-1) = %d (binary: ", n & (n-1));
printBinary(n & (n-1));
printf(")\n");
printf("Since result is 0, %d is a power of 2.\n", n);

return 0;
}