# Using Bit fields

Discussion in 'C Programming' started by mt, Apr 5, 2011.

1. ### mtGuest

Can I use bit fields to create my own variable of 32 bits, 20 of which
I will use for something, and use the rest as 3 1 byte values, and can
i them make an array of it?
Thanks

mt, Apr 5, 2011

2. ### GeoffGuest

On Mon, 4 Apr 2011 18:46:06 -0700 (PDT), mt <> wrote:

>Can I use bit fields to create my own variable of 32 bits, 20 of which
>I will use for something, and use the rest as 3 1 byte values, and can
>i them make an array of it?
>Thanks

Well, if by "byte" you mean 8 bits, then I think the answer is no.
Reason: 3 x 8 = 24, 24 + 20 = 44, 44 bits don't fit into a variable of
32 bits.

You're welcome.

Geoff, Apr 5, 2011

3. ### James KuyperGuest

On 04/04/2011 09:46 PM, mt wrote:
> Can I use bit fields to create my own variable of 32 bits, 20 of which
> I will use for something, and use the rest as 3 1 byte values, and can
> i them make an array of it?

I'm trying to guess what you wanted, and I can't make the bit counts
come out right. Is this roughly what you're looking for?

struct my_own {
int something:20;
int one:8;
int two:8;
int three:8;
} my_array[200];

Note that (sizeof array[0])*CHAR_BITS >= 44. Is this otherwise as you
wanted?

--
James Kuyper

James Kuyper, Apr 5, 2011
4. ### Eric SosmanGuest

On 4/4/2011 9:46 PM, mt wrote:
> Can I use bit fields to create my own variable of 32 bits, 20 of which
> I will use for something, and use the rest as 3 1 byte values, and can
> i them make an array of it?

Your bit-counting seems off, but you can make a struct of
four bit-fields, like

struct thing {
int something : 20;
int small1 : 4;
int small2 : 4;
int small3 : 4;
};

.... and you can make an array of such structs

struct thing array[42];

.... allowing `array[3].something = 9;' and `array[17].small2 = 3;'
and so on. You cannot make arrays of the individual fields, as in

int something : 20;
int small[3] : 4; /* BZZZZT! */
};

There are a few portability gotchas. First, C only defines bit-
fields that are based on `int', `signed int', `unsigned int', and
(in the C99 Standard) `_Bool', and a bit-field can only have as many
bits as its base type has. (A given compiler may allow other base
types, but is not obliged to.) Since the various flavors of `int'
can be as narrow as 16 bits, the `:20' width may be too wide for some
compilers and might not work. You'll get a compile-time diagnostic
if it doesn't, though.

Second, a compiler is free to treat a plain `int' bit field as
either signed or unsigned, at its discretion. A free-standing `int'
variable is always signed, but this needn't hold for bit-fields.
This means that `array[12].small1 = -1;' may store a minus one on
some implementations, but a plus fifteen on others. The bad news is
that you might not get any compile-time diagnostic, and be stuck with
mysterious malfunctions at run-time. The good news is that if you
explicitly write `signed int small1 : 4' or `unsigned int small2 : 4'
you can override the compiler's preference. Recommendation: Always
use `signed int' or `unsigned int' as the base type for a bit-field,
never plain `int'.

--
Eric Sosman
d

Eric Sosman, Apr 5, 2011
5. ### mtGuest

On Apr 4, 10:21 pm, Eric Sosman <> wrote:
> On 4/4/2011 9:46 PM, mt wrote:
>
> > Can I use bit fields to create my own variable of 32 bits, 20 of which
> > I will use for something, and use the rest as 3 1 byte values, and can
> > i them make an array of it?

>
>      Your bit-counting seems off, but you can make a struct of
> four bit-fields, like
>
>         struct thing {
>             int something : 20;
>             int small1 : 4;
>             int small2 : 4;
>             int small3 : 4;
>         };
>
> ... and you can make an array of such structs
>
>         struct thing array[42];
>
> ... allowing `array[3].something = 9;' and `array[17].small2 = 3;'
> and so on.  You cannot make arrays of the individual fields, as in
>
>             int something : 20;
>             int small[3] : 4;    /* BZZZZT! */
>         };
>
>      There are a few portability gotchas.  First, C only defines bit-
> fields that are based on `int', `signed int', `unsigned int', and
> (in the C99 Standard) `_Bool', and a bit-field can only have as many
> bits as its base type has.  (A given compiler may allow other base
> types, but is not obliged to.)  Since the various flavors of `int'
> can be as narrow as 16 bits, the `:20' width may be too wide for some
> compilers and might not work.  You'll get a compile-time diagnostic
> if it doesn't, though.
>
>      Second, a compiler is free to treat a plain `int' bit field as
> either signed or unsigned, at its discretion.  A free-standing `int'
> variable is always signed, but this needn't hold for bit-fields.
> This means that `array[12].small1 = -1;' may store a minus one on
> some implementations, but a plus fifteen on others.  The bad news is
> that you might not get any compile-time diagnostic, and be stuck with
> mysterious malfunctions at run-time.  The good news is that if you
> explicitly write `signed int small1 : 4' or `unsigned int small2 : 4'
> you can override the compiler's preference.  Recommendation: Always
> use `signed int' or `unsigned int' as the base type for a bit-field,
> never plain `int'.
>
> --
> Eric Sosman
>

yes, my bit count was off because I meant to day 3 4 bit values.
Thanks for the invaluable advice. I will print it and post it on my
work board.

mt, Apr 5, 2011