values changed in bitfields in structure

Question

Can anyone explain the output , how the value is stored and calculated?

#include<stdio.h>
struct bitfield
{
    unsigned f1:1;
    unsigned f2:2;
    unsigned   :3;
    unsigned f4:4;
    unsigned f5:5;
    unsigned f6:6;
    unsigned f7:1;
    unsigned f8:8;
} bf;

main()
{
    bf.f1 = 1;
    bf.f2 = 0x3;
    bf.f4 = 0xff;
    bf.f5 = -4;
    bf.f6 = 0377;
    printf("%d %d %d %d %d %d", bf.f1, bf.f2, bf.f4, bf.f5, bf.f6, bf.f8);
}

Output: 1 3 15 28 63 0

I changed the formatting of the code to make it more readable. — idoby, Jun 10 '13 at 09:42
What needs explaining? This isn't a very useful question. It's like saying "1 + 1 = 2 -- can someone explain?". It all looks obvious, so unless you say what part you don't understand, it's hard to answer this. — Kerrek SB, Jun 10 '13 at 09:50
f1 hast 1 bit, it is 1. f2 hast 2 bits an can store 0x3. f4 has 4 bits (range 0-15), storing 0xff sets it to max (15). f5 has 5 bits, 4 = 00100, -4 = 11100 (two's complement), and this is binary equal to 28. f6 has 6 bits, max value = 63. 0377 (oktal) = 255 dec. all 6 bits set to 1, so its value is 63. f8 is never set. — WoJo, Jun 10 '13 at 09:56

score 4 · Answer 1 · answered Jun 10 '13 at 09:50

Very short rundown.

First, bf is an uninitialised global variable. This means it will end up in the .bss segment, which is typically zero-initialised on startup (although you can pass -fno-zero-initialized-in-bss to GCC to stop this, not sure about MSVC, and of course it depends on your crt0). This explains the value of f8, since you haven't written to it.

f1 is 1. You assign it 1. That one's obvious. Same with f2 (since hex 3 is dec 3).

f4 is because the field for f4 is only 4 bits wide. 0xFF is an 8 bit pattern which is all ones, which is then truncated to 4 bits, and is hence 15 (the highest value that can be represented with 4 bits).

f5 is due to a signed/unsigned conversion. The 5-bit two's compliment representation of -4 is 11100. If you interpret that value as unsigned (or rather, just a plain binary -> decimal conversion), you get 28.

f6 is 63 because of an octal conversion. Any C literal number beginning with a zero is treated as octal. Octal 377 is decimal 255 (which is 11111111 in 8-bits), which is then truncated to 6 bits, leaving 111111. This is 63.

Global variables are *guaranteed* to be 0-initialised by the C++ standard. — Angew is no longer proud of SO, Jun 10 '13 at 10:08

score 2 · Answer 2 · answered Jun 10 '13 at 09:49

Values are stored in the field you specify. However, since in some cases, e.g bf.f4 = 0xff;, the value doesn't fit, it will be losing the upper bits, hence it prints 15 (0x0F). Similarly for -4 stored in f5 -4 = 0xFFFFFFFC as a 32-bit integer, but when stored as an unsigned 5-bit integer, it becomes 0x1C, or 28. The same principle applies to f6.

There is also 3 bit "gap" using an unnamed member between f2 and f4.

Internally, the compiler will do this by using AND, SHIFT and OR operations.

Note that we can't know if f1 is the highest or the lowest bit of the whole value that the fields are stored in. This is something that the compiler implementation will decide on - as long as it's done the same way every time.

score 1 · Accepted Answer · answered Jun 10 '13 at 09:59

unsigned fx:n; // Only use the least significant n bits.

               //                        Binary    Decimal
bf.f1 = 1;     // 1    == [0000 0001]:1   == 1      == 1
bf.f2 = 0x3;   // 0x3  == [0000 0011]:2   == 11     == 3
bf.f4 = 0xff;  // 0xff == [1111 1111]:4   == 1111   == 15
bf.f5 = -4;    // -4   == [0xfffffffc]:5  == 11100  == 28
bf.f6 = 0377;  // 0377 == [1111 1111]:6   == 111111 == 63

score 0 · Answer 4 · answered Jun 10 '13 at 09:56

unsigned f1:1;           // 1 bit is allocated. 
bf.f1=1;                 // you are storing 1 works fine.

unsigned f2:2;           // 2 bit is allocated.
bf.f2=0x3;               // 3 == '11' in binary so 2 bits are enough so when you print 3 is printed.

unsigned   :3;

unsigned f4:4;          // 4 bit is allocated.
bf.f4=0xff;             // ff is represented as 1111 1111 in binary, 
// but only 4 bits are allocated so only f which is 1111 
// in binary gets stored in this. when you print using %d, 15 is getting printed.


unsigned f5:5;         // 5 bits are allocated
bf.f5=-4;              // -4 in binary for 5 bits is 11100 but you are printing it as %d so it will print 28. and so on...

hope this will help.

values changed in bitfields in structure

4 Answers4