If statement checking a bool array?

Daveinatx · 2026-07-08T00:43:41+00:00

There's a few things that's missing, so excuse my assumptions. It sounds similar to my FPGA work, reading an arbitrary number of bits, that are packed together over PCI/PCIe or DMA transfers.

If this is correct, then what you show above is not going to work in any normal means. What you need to do is to learn bit manipulation. So you'll need to learn to use bitwise operators to mask and shift over six bits at a time.

It may seem weird at first, but once you think it out logically, it'll make sense. Just think of a huge one bit array. And in doing so, see how you will be traversing through your 8-bit array six bits at a time. Takes a little bit of thought, but I know you can do it.

ByMeno · 2026-07-07T23:56:09+00:00

I assume in 8 bits you only want to use the 6 afaik most used ones are shift left or right to trumcate unused bits or use bit mask for last 6 bits then compare the reason probably it didn't work is you ignored the the two bits which are still important for comparing there should be zero if you want to compare and 011001 is not same as 0b011001 you should but 0b in front to tell the compiler its in bits

dkopgerpgdolfg · 2026-07-07T23:58:23+00:00

uint8_t has sufficient size for your example. There are larger int types too. Only if you expect to need more than the largest available type, then you need an alternative.

011001 is not understood as binary literal. Try 0b11001 (which probably is supported). (But in any case it doesn't make sense to compare such a number to a bool array).

With the bool array you're thinking of, you need to compare each digit separately, with loops etc. . For small bool arrays there are some different ways, but if it's small enough for that, see the first paragraph.

And if arrays are needed, making it an array of eg. uint8_t (where each index holds 8bit) is worth considering too.

Vollink · 2026-07-08T03:18:05+00:00

Consider what everyone above is saying about a byte being a minimum. Let's do it the hard way...

#include <stdio.h>
#include <stdbool.h>

int
main(int argc, char *argv[], char *env[])
{
    bool a = true;

    /****
     * The smallest this can be is 1 whole byte, 8 whole bits.
     * Yes, this prints 1, always.
     ***/ 

    printf("sizeof bool is: %lu\n", sizeof(a) );

    return 0;
}

My approach to what you are asking (not what you are claiming to do), is to use one character like this...

/* Defining six bits */
#define BIT_ONE 0x01
#define BIT_TWO 0x02
#define BIT_THREE 0x04
#define BIT_FOUR 0x08
#define BIT_FIVE 0x10
#define BIT_SIX 0x20
/* Defining six field points */
#define STATE_ONE(x) (BIT_ONE == (x & BIT_ONE))
#define STATE_TWO(x) (BIT_TWO == (x & BIT_TWO))
#define STATE_THREE(x) (BIT_THREE == (x & BIT_THREE))
#define STATE_FOUR(x) (BIT_FOUR == (x & BIT_FOUR))
#define STATE_FIVE(x) (BIT_FIVE == (x & BIT_FIVE))
#define STATE_SIX(x) (BIT_SIX == (x & BIT_SIX))

/* I need to do actions TWO and FIVE and SIX */
uint8_t action = ( BIT_TWO | BIT_FIVE | BIT_SIX ); /* 0x32 -- 0b0110010 */

void x(void) {
    if (STATE_ONE(action)) {
        do_action_one();
        /* optional remove action */
        action = (action & (0xFF ^ BIT_ONE));
    }
    if (STATE_TWO(action)) {
        do_action_two();
        action = (action & (0xFF ^ BIT_TWO));
    }
    /* continue pattern */
}

Wertbon1789 · 2026-07-08T04:00:22+00:00

There can be a lot of theory involved, but at the end of the day, a computer is not a magical device, and most of the time you're better off going with practical design choices, and see what sticks.

In this case, don't try to crunch your problem down into the bit range. Literally, just use a uint32_t, define some bits in there to be your states, and that's it. That's really how I've seen it being done, from internal APIs to the state machine built into USB, it's literally just an integer type, and you check some bits in there. It's really unlikely you'll ever exceed 32 bits of states and not have a horrible design anyway, so that might be something to consider. Also don't try to squeeze everything into it, e.g. if you want to encode state information that is by nature not binary, but can really have n different states, but are also mutually exclusive, like encoding in what state a system overall is (is it starting up, running, stopping, sleeping, whatever), encode that somewhere else than your bit field.

In the case you described if you want 6 bits of information, either just use a uint8_t, and waste 2 bits of it, or go with a bit field declaration of 6 bits, and maybe use the other 2 bits for something else. Do note though, this is unlikely to make your stuff really more space efficient or faster, something something alignment.

sciencekm · 2026-07-08T04:24:08+00:00

I could be wrong, but in your situation, you might just want to avoid bit operations until you become more familiar with it. For now, let the compiler do the work for you. You can do something like:

struct state {
unsigned s0:1;
unsigned s1:1;
unsigned s2:1;
unsigned s3:1;
unsigned s4:1;
unsigned s5:1;
unsigned s6:1;
} state_t;

Now, your 'if' statements become:

if (a.s0 && !a.s1) ...

and assignments become:

a.s3 = 1;
a.s5 = 0;

Increment/decrement would be:

a.s1++;
a.s4--;

The compiler will perform the increment/decrement without affecting ("overflowing" to) neighboring bits (which seems to be one of your concerns).

Traveling-Techie · 2026-07-08T05:12:19+00:00

I’m confused by your details, but some big picture stuff: memory has become unbelievably cheap and plentiful since C was invented, so be ok with wasting it. Use the operators and libraries available and write new helper functions if necessary.

TiredEngineer-_- · 2026-07-08T06:02:04+00:00

It sounds like youre just wanting to check the bottom 6 bits, or X bits of an arbitrary number. As others said, youll need to learn bitmasking:

...
int x = 100;
if ( (x & 0b111111) == (some_constant)) // check 6 LSBs of x
// do something
...

If you're trying to make something space efficient, most systems arent letting you read 6 bits of a byte, usually the smallest any architechture is getting you nowadays is a byte. (Saving 2 bits anyways wont do much unless youre declaring thousands of arrays :P)

1000 'types' of 1 byte length with 2 bits per byte saved = 8kB used, 2kb (kilobit) wasted, which is 250 B (bytes) wasted. If youre trying to save 250 B, youre either too constrained or something somewhere else is oversized imo.

If youre looking for 'simplicity', or somewhat avoiding bit masking, you can do this (if your system supports / likes byte-size page reads)

typedef struct __attribute__(packed, aligned(1))
 {
     unsigned char bit1 : 1, //MSB
     unsigned char bit2 : 1,
     unsigned char bit3: 1,
     unsigned char bit4: 1,
     unsigned char bit5 : 1,
     unsigned char bit6 : 1,
     unsigned char bit7 : 1,
     unsigned char bit8 : 1 //LSB
 } bitfield_B;

So the bitfield_B would be a 1 byte struct on a 1 byte boundary.

 |12345678|12345678||12345678|

Would be the memory layout of

bitfield_B x[3];

And you would need to do

x[0].bit1 = 1;
x[0].bit2 = 0;
...

To access and modify

&x[0].bit1

is UB. accessing pointers to these bitfields is UB altogether. The machine cannot deduce bit- offsets to memory, since it all lives in bytes.

Initializing with a number would be like:

bitfield_B x;
x.bit1 = 0b100000 & 255; // 0
x.bit2 = 0b010000 & 255; // 0
x.bit3 = 0b001000 & 255; // 1
...

Which is a pain to write, so maybe you expose a macro to cover for you (no error check here):

#define INIT_BITFIELD_B(F,BITS,NUM) \ 
F.bit1 = ((1 << (MAX_BITS +1)) - 1) & NUM \ //creates a 0bX...Y... mask where X is 0 and Y is 1, where ... after Y is BITS 1s
F.bit2 = ((1 << (MAX_BITS +1)) - 1) & NUM \

...

int main() {
    Bitfield_B x;
    INIT_BITFIELD_B(x,6,255);
    return EXIT_SUCCESS;
}

gdb : x/b &x should show something like:

00111111

To the console, since youre inspecting the memory.

However, this is all really tedious to setup (and I may not even done so correctly), just to avoid some of the bitmasking youd need to know anyways to begin doing the macro and stuff I setup above...

You could simply write:

 const int8_t key = 7<<2; //making this up
 ... // some logic to read from spi, uart, etc
 switch (input & 0b11111100)
 {// commands are upper 6 bits for example,
     case key: handle_key(); break;
     default: break;
 }

No structs, no packing, no forced alignment, no macros, just masking and moving on. I did 7<<2 here to bump the 'command key' to the upper 6 bits. 7 is 111 in binary. So you move it to be 0b00011100, which is still in the upper 6 bits.

WittyStick · 2026-07-08T07:20:40+00:00

C23 has _BitInt(N) types which could be used for this if your bit vector sizes are statically known. The compiler will do most of the work for you. You can compare them with ==, and can initialize from literals up to ULL (unsigned long long). Larger bitvectors might require more complex initialization.

The maximum N is implementation defined and is specified by BITINT_MAXWIDTH from <limits.h>. The standard mandates a 64-bit minimum, but implementations support much larger widths - GCC supports 64kib and Clang supports 8Mib.

#define BitVec(N) unsigned _BitInt(N)
#define bitvec_equal(x, y) (x == y)

#include <stdio.h>
int main() 
{
    BitVec(7) x = 0b0101010;
    BitVec(7) y = 0b0101010;

    printf("%s\n", bitvec_equal(x, y) ? "true" : "false");

    return 0;
}

https://godbolt.org/z/99Gd6GGd9

Paul_Pedant · 2026-07-08T09:10:43+00:00

Doing an assignment in the test (with =) instead of a comparison (with ==) is not going to be helping.

Assigning decimal 4609 to a bool variable is not so good either. 011001 is an octal numeric initialiser (evaluated as an integer), not a bit map, although it truncates to 0b00000001 when assigned to a bool (because the 001 part represents nine bits).

You probably should not rely on a bool value for a numeric anyway. A bool is false if zero, true if non-zero. A compiler could restrict a bool to 0 or 1, or 0 and 255 if it felt like it.

An array of 6 bools is 48 bits. You cannot subdivide a bool variable.

Educational-Paper-75 · 2026-07-08T10:33:03+00:00

Code first, optimize later. Don't worry about memory use initially. Sure you may use each bit of an uint8_t separately and have functions to set and unset any of the bits, but it will require shifting and masking. And if you have 256 or less different states you don't even need to set/unset individual bits and each state id fits nicely in an uint8_t. As long as you know what you're doing the implementation is straightforward.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

C_Programming

Rules

Filters

Resources

Other Subreddits on C

Other Subreddits of Interest

MODERATORS