Using Bit fields

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

  1. mt

    mt Guest

    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
    #1
    1. Advertising

  2. mt

    Geoff Guest

    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
    #2
    1. Advertising

  3. mt

    James Kuyper Guest

    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
    #3
  4. mt

    Eric Sosman Guest

    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

    struct badthing {
    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
    #4
  5. mt

    mt Guest

    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
    >
    >         struct badthing {
    >             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
    #5
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Replies:
    3
    Views:
    1,776
    Timothy Bendfelt
    Jan 19, 2007
  2. Craig
    Replies:
    0
    Views:
    1,282
    Craig
    Dec 1, 2006
  3. Replies:
    9
    Views:
    990
    Juha Nieminen
    Aug 22, 2007
  4. Mike -- Email Ignored

    Bit Order in Bit Fields

    Mike -- Email Ignored, May 2, 2009, in forum: C++
    Replies:
    0
    Views:
    386
    Mike -- Email Ignored
    May 2, 2009
  5. Jeff.M
    Replies:
    6
    Views:
    183
    Lasse Reichstein Nielsen
    May 4, 2009
Loading...

Share This Page