C语言布尔数组与位运算：8输出移位寄存器控制优化咨询

Great question—this is exactly the kind of tradeoff between readability and performance that comes up all the time with hardware control like SPI. The good news is you can have both: the speed of using a uint8_t for SPI, and the intuitive "array-like" syntax for individual switches. Here are the best approaches:

1. Inline Helper Functions (Best Balance of Readability + Performance) #

Wrap the bitwise operations in tiny, inline functions. Since these are marked inline, the compiler will expand them directly into your code—no function call overhead, just the raw bit operations (same speed as writing the bits manually).

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

// Set the nth switch (0-7) to a given state (true = on, false = off)
static inline void switch_set(uint8_t *switch_val, int idx, bool state) {
    if (state) {
        *switch_val |= (1U << idx);  // Set the target bit
    } else {
        *switch_val &= ~(1U << idx); // Clear the target bit
    }
}

// Get the current state of the nth switch
static inline bool switch_get(uint8_t switch_val, int idx) {
    return (switch_val & (1U << idx)) != 0;
}

Usage Example #

This reads just like working with a boolean array, but under the hood it's manipulating a single uint8_t:

uint8_t switch_val = 0; // All switches off initially

switch_set(&switch_val, 0, true);  // Turn switch 0 on (equivalent to 0b00000001)
switch_set(&switch_val, 1, false); // Ensure switch 1 stays off
bool is_switch_3_on = switch_get(switch_val, 3); // Check switch 3's state

// Send directly over SPI—no conversion needed!
spi_send(switch_val);

2. Macro Definitions (Even More Minimal) #

If you want to avoid function calls entirely (though inline functions are just as fast), you can use macros to mimic array syntax. These are resolved at compile time, so no runtime cost:

#define SWITCH_SET(val, idx, state) \
    do { \
        if (state) (val) |= (1U << (idx)); \
        else (val) &= ~(1U << (idx)); \
    } while(0)

#define SWITCH_GET(val, idx) \
    (((val) & (1U << (idx))) != 0)

Usage Example #

uint8_t switch_val = 0;

SWITCH_SET(switch_val, 0, true);
bool switch_2_state = SWITCH_GET(switch_val, 2);

3. Union + Bitfields (Use With Caution) #

You can use a union to overlay a uint8_t with a struct of single-bit fields. This lets you access individual bits as named variables, but be careful: the order of bits in the struct depends on your compiler's endianness and packing rules, which might not match your shift register's bit order.

typedef struct {
    bool sw0 : 1; // Bit 0 (LSB)
    bool sw1 : 1;
    bool sw2 : 1;
    bool sw3 : 1;
    bool sw4 : 1;
    bool sw5 : 1;
    bool sw6 : 1;
    bool sw7 : 1; // Bit 7 (MSB)
} SwitchBits;

union SwitchControl {
    uint8_t raw;    // Raw byte for SPI transmission
    SwitchBits bits; // Individual switch access
};

Usage Example #

union SwitchControl sw;
sw.raw = 0; // Start with all switches off

sw.bits.sw0 = true; // Turn switch 0 on
spi_send(sw.raw);   // Send the raw byte directly to SPI

Just double-check that your compiler orders the bits the same way your shift register expects (e.g., is sw0 the first bit shifted out?). If not, you'll need to reorder the struct fields to match.

Key Performance Note #

All three methods compile down to the same low-level bitwise instructions—no runtime overhead, just as fast as manually setting the uint8_t with 0b00000001. The boolean array approach you're using now involves multiple memory accesses (for each element in the array), which is definitely slower for SPI's tight timing requirements.

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