C / C++ / MFC

3-Nov-04 9:18

I don't understand the following code. Could someone please explain it to me?

struct SomeStruct
{
   union
   {
      unsigned int field;
      struct
      {
      unsigned x:     1;
      unsigned y:     1;
      unsigned z:     1;
      unsigned space: 3;
      };
   };
};

I am guessing that this is making use of Anonymous Unions.

There is a struct containing a union containing a struct... confusing.

Also I don't understand this notation "unsigned x: 1;", what is this saying?

My best guess that field would tell you which variable to use and then you would access it like:

SomeStruct mystruct;

For example if field donoted using x you would access by mystruct.x ??

Finally, is this C/C++ or just for C++?

Thanks

David Crow3-Nov-04 9:38

David Crow

3-Nov-04 9:38

smesser wrote:
I am guessing that this is making use of Anonymous Unions.

You are correct.

smesser wrote:
Also I don't understand this notation "unsigned x: 1;", what is this saying?

That the variable only occupies 1 bit.

smesser wrote:
For example if field donoted using x you would access by mystruct.x ??

Correct. In this particular example, accessing member x would also be accesssing one bit of member field. That's the whole premise of a union. All members start at the same address because a union variable can contain only one of its members at a time.

smesser wrote:
Finally, is this C/C++ or just for C++?

Unions are used in both languages. The difference comes in how you declare union variables. With C, you must use the union keyword. In C++, the union keyword is unnecessary.

"Opinions are neither right nor wrong. I cannot change your opinion of me. I can, however, change what influences your opinion." - David Crow

Steve Messer3-Nov-04 9:45

3-Nov-04 9:45

Thanks for your answer.

So your saying that each item in the union occupies 1 bit so then space is the total number of bits or it is the total number of choices?

So if I want to create a variable to store this data I would just do this?

bool my_x = mystruct.x;

Sorry, for the dumb questions. I have never used unions before much less anonymous ones.

Thanks

Henry miller3-Nov-04 10:32

Henry miller

3-Nov-04 10:32

Not quite. Read the other replys.

Each item in the union STARTS at the same place. They are used either when you know that of two different variables only one is needed (but which one is not known in advance), or when you want to use the same data in different ways. In your case, field takes 32 bits, on a 32 bit system. x represents bit 1 of field, y represents bit 2, and space represents 4-6.

if you do:
struct somestruct mystruct;
mystruct.field = 0xa8000000;

than field (dropping the last 24 bits which are all 0) contains the following in binary:
10101000

Therefore
mystruct.x == 1
mystruct.y == 0
mystruct.z == 1
mystrict.space = 2

(Note, double check this, I might have the layout backwards. I cannot remember this unless I'm deep into such code)

Bitfields almost always make your program larger and slower than just using an int. Therefore the only time you normally see them is in networking and hardware. Both are cases where limits in transfer speed or length are far more important that CPU time or memory. It is generally not worth your time to use them elsewhere.

Warning, whenever you see data structures like this, the author knew something about the exact hardware in question! There are dragons lurking for anyone who trys to run this on anything else without a lot of care. If you do not understand what I'm getting at, stick to less advanced programs. Many programers get by without ever needing to deal with bitfiels.

Joaquín M López Muñoz3-Nov-04 10:06

3-Nov-04 10:06

Your question poses a number of interesting points Smile | :)

I am guessing that this is making use of Anonymous Unions.

Yes. An anonymous union is just a way to tell the compiler that the enclosed members share the same storage. For instance:

union{
  int x;
  int y;
}
 
x=100;
cout<<y; // outputs 100 !

Here, we've used an anonymous union to locally declare two variables sharing the same position in memory. Most of the time, anonymous unions are used for type definition inside a struct:

struct foo{
  union{
    int x;
    int y;
  };
};
 
foo f;
f.x=100;
cout<<f.y; // outputs 100

Also I don't understand this notation "unsigned x: 1;", what is this saying?

This is an orthogonal feature called bitfields. By adding a bitfield specification to a member, we instruct the compiler to use the indicated bits for storage instead of what it normally would take to store the member. For instance:

struct foo{
  unsigned x:2;
  unsigned y:2;
  unsigned z:2;
  unsigned w:2;
};

Here, member variables x, y, z and w will take only two bits each, and the resulting foo will only occupy one byte (alignment issues aside.) Of course, these variables will not be able to hold a value greater than what can be expressed with two bits (3) --the compiler cannot do miracles.

What do we have if we combine these two features?

struct SomeStruct{
  union{
    unsigned int field;
    struct{
      unsigned x:     1;
      unsigned y:     1;
      unsigned z:     1;
      unsigned space: 3;
    };
  };
};

By virtue of the anonymous union, field will share the same storage as x, y, y and space. And because we are using bitfields on those, the overall effect is that SomeStruct.x will refer to the first bit of SomeStruct.field, SomeStruct.y to the second bit, etc. Got it? This kind of constructs (which are very low-level and depend on non-portable issues like type alignment, size of primitive types, big- or little-endiannness, etc.) are commonly used to reproduce bit-specified data structures like those you can find in some data protocols (for instance, TCP data units), and allow the programmer to handle the data at the sub-byte level.

Finally, is this C/C++ or just for C++?

Neither Smile | :)

This construct relies on what we could call an "anonymous struct":

struct{
  unsigned x:     1;
  unsigned y:     1;
  unsigned z:     1;
  unsigned space: 3;
};

Alas, anonymous structs are not standard C or C++, though MSVC admits them. Apart from this, the rest is C/C++ (though its usage would differ in minor syntactic issues.)

Joaquín M López Muñoz
Telefónica, Investigación y Desarrollo
Want a Boost forum in Code Project? Vote here[^]!

Steve Messer3-Nov-04 10:18

Re: Union question[modified]

3-Nov-04 10:18

Thanks for another very good explanation.

Then, Why would one put at the end of the union:

unsigned space : 3

Which just seems to be the total bits in the union is this the case and why would you do it?

So, then to access anything from:

So, to access x,y, or z you would:

SomeStuct mystruct;

int my_x = mystruct.x;
int my_y = mystruct.y;
int my_z = mystruct.z;

How would you get the values from field ?

Thanks

Antony M Kancidrowski4-Nov-04 2:24

Antony M Kancidrowski

4-Nov-04 2:24

At a guess the unsigned space:3 is a mistake. I expect what space is meaning to contain is the other bits that an unsigned int occupies. On 32-bit machines space would be 29, i.e. 32 - 1 - 1 - 1 = 29.

smesser wrote:
How would you get the values from field ?

unsigned int my_field = mystruct.field;

Or do you mean how do you get x, y and z from mystruct.field?

Ant.

I'm hard, yet soft.
I'm coloured, yet clear.
I'm fruity and sweet.
I'm jelly, what am I? Muse on it further, I shall return! - David Walliams (Little Britain)

Steve Messer4-Nov-04 3:42

is there platform-independent FillMemory function in C/C++!?

4-Nov-04 3:42

Actually here is the actual struct

typedef struct  
{ 
    union 
    { 
        unsigned int field; 
        struct 
        { 
                unsigned xyz_offset:                            1; 
                unsigned collision_fwd_fuselage:                1; 
                unsigned collision_aft_fuselage:                1; 
                unsigned collision_lt_wing:                     1; 
                unsigned collision_rt_wing:                     1; 
                unsigned collision_lt_tail:                     1; 
                unsigned collision_rt_tail:                     1; 
                unsigned collision_vt_tail:                     1; 
                unsigned collision_lt_gear:                     1; 
                unsigned collision_rt_gear:                     1; 
                unsigned collision_nose_gear:                   1; 
                unsigned collision_prop1:                       1; 
                unsigned collision_prop2:                       1; 
                unsigned collision_prop3:                       1; 
                unsigned collision_prop4:                       1; 
                unsigned weapon_strike:                         1; 
                unsigned space:                                16; 
        }; 
    }; 
}CollisionType;

Yes, I wanted to get x,y, and z.

I think you would do it like this:

For example:

if( mystruct.x )
{
   do_x_stuff();
}

if( mystruct.y )
{
   do_y_stuff();
}

if( mystruct.z )
{
   do_z_stuff();
}

Since each bit is either on or off I believe this would work.

clayman873-Nov-04 9:04

clayman87

3-Nov-04 9:04

Hi!

I'm looking for some platform-independent C/C++ function which would be to pre-fill a large memory area with some value, just like FillMemory in win32 does.

Does such a function exist, or do I have to make my own in assembly?

Re: is there platform-independent FillMemory function in C/C++!?

Joaquín M López Muñoz3-Nov-04 9:15

Re: is there platform-independent FillMemory function in C/C++!?

3-Nov-04 9:15

memset, in <string.h>.

Joaquín M López Muñoz
Telefónica, Investigación y Desarrollo
Want a Boost forum in Code Project? Vote here[^]!

Rick York3-Nov-04 9:15

Rick York

3-Nov-04 9:15

Have you looked at memset ?

__________________________________________
a two cent stamp short of going postal.

Re: is there platform-independent FillMemory function in C/C++!?

clayman873-Nov-04 10:13

clayman87

3-Nov-04 10:13

Is it elegant to use 'memset' in a full C++ environment?

Re: is there platform-independent FillMemory function in C/C++!?

Joaquín M López Muñoz3-Nov-04 11:02

Re: is there platform-independent FillMemory function in C/C++!?

3-Nov-04 11:02

Is it elegant to use 'memset' in a full C++ environment?

It is all the rage in C++ parties lately Smile | :)

Seriously now, its usage is just fine, and, unlike FillMemory, it is platform-independent, which is what you were looking for.

Joaquín M López Muñoz
Telefónica, Investigación y Desarrollo
Want a Boost forum in Code Project? Vote here[^]!

clayman873-Nov-04 10:34

clayman87

3-Nov-04 10:34

and, of course, is there any way to put not bytes but ints (4bytes) after each other?

cause memset seems suitable only for single bytes...

Re: is there platform-independent FillMemory function in C/C++!?

Joaquín M López Muñoz3-Nov-04 11:06