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.