请求提供基于数组bit index创建连续位Byte mask的C语言代码

Here's a straightforward, robust implementation to create your desired byte mask. The function takes the start and end bit indices (0-based, matching your example where bits 1 and 2 produce 00000110), validates inputs to avoid bugs, and generates the mask with the specified consecutive bits set to 1.

Code Implementation #

#include <stdint.h>
#include <stdbool.h>

// Generates a byte mask where bits from start_bit to end_bit (inclusive) are 1
// Returns 0 if input indices are invalid
uint8_t generate_byte_mask(int start_bit, int end_bit) {
    // Validate input: bits must be within 0-7, and start <= end
    if (start_bit < 0 || end_bit > 7 || start_bit > end_bit) {
        return 0;
    }

    // Calculate the number of consecutive bits to set
    int bit_count = end_bit - start_bit + 1;

    // Create a mask with 'bit_count' consecutive 1s, then shift to the correct position
    return ((1U << bit_count) - 1) << start_bit;
}

// Example usage
#include <stdio.h>

int main() {
    int myArray[] = {1, 2}; // Your input array
    uint8_t mask = generate_byte_mask(myArray[0], myArray[1]);
    
    // Print mask in binary to verify
    printf("Mask (binary): ");
    for (int i = 7; i >= 0; i--) {
        printf("%d", (mask >> i) & 1);
    }
    printf("\nMask (decimal): %u\n", mask);

    // Example: Use mask with another byte
    uint8_t target_byte = 0xFF; // Example byte
    uint8_t result_and = target_byte & mask;
    uint8_t result_or = target_byte | mask;
    uint8_t result_xor = target_byte ^ mask;

    printf("AND result: %u\n", result_and);
    printf("OR result: %u\n", result_or);
    printf("XOR result: %u\n", result_xor);

    return 0;
}

How It Works #

• Input Validation: First, we check that the start/end bits are within the 0-7 range (since we're working with a single byte) and that the start index isn't greater than the end index. This prevents invalid shifts or nonsensical masks.
• Mask Calculation:
  1. (1U << bit_count) - 1: Creates a value with bit_count consecutive 1s starting from the least significant bit. For your example, bit_count = 2, so this gives 00000011 (decimal 3).
  2. << start_bit: Shifts that block of 1s to the correct position. For your example, shifting left by 1 gives 00000110 (decimal 6), which matches your desired output.
• Usage: The returned uint8_t mask can directly be used with &, |, or ^ operations on other bytes, just as you intended.

Notes #

• We use 1U (unsigned integer) to avoid issues with sign extension when shifting for larger bit counts.
• If invalid inputs are passed (e.g., start > end, or bits outside 0-7), the function returns 0 as a safe default—you can adjust this to return an error code or handle it differently if needed.

内容的提问来源于stack exchange，提问作者Eifel