Unioning structs of different sizes?

Is it safe to do something like

Code:

typedef union
{
    struct
    {
          int a;
          int b;
          int c;
          int d;
    } val1;

    struct
    {
          int e;
          int f;
    } val2;
}my_u;

When I refer to the val2 field in the union, I only care about accessing a and b. Do I need to add the padding to val2?

Nope.
Of course I assume you mean e and f, not a and b.

Originally Posted by iMalc

Nope.

Damn, that would have made things easy.

Originally Posted by iMalc

Of course I assume you mean e and f, not a and b.

Sort of. I want to access a and b via e and f.

Wait a minute, I think you misunderstand. You can pretty much union anything, and in this case there shouldn't be any alignment issues.

Originally Posted by whiteflags

Wait a minute, I think you misunderstand. You can pretty much union anything, and in this case there shouldn't be any alignment issues.

Yeah, when iMalc said "nope", he meant that no, you don't have to worry about adding any padding and yes, what you want to do is fine.

Thanks for the clarification. I've never done a union that had fields of different sizes. I always assumed that each field in a union had to be the same size.

Originally Posted by homer_3

Thanks for the clarification. I've never done a union that had fields of different sizes. I always assumed that each field in a union had to be the same size.

Then what would be the point of unions? Everyone would just use casts to get the same thing done.

Originally Posted by manasij7479

Then what would be the point of unions? Everyone would just use casts to get the same thing done.

What's the point of C++? Just use assembly. Oh yea, convenience.

Originally Posted by homer_3

What's the point of C++? Just use assembly. Oh yea, convenience.

You missed my point.
If unions only allowed members of same size, it would be much more convenient to just use casts.
Or do you find verbose stuff more convenient?

Originally Posted by manasij7479

Then what would be the point of unions? Everyone would just use casts to get the same thing done.

If you were thinking of using unions as a convenient alternative to reinterpret_cast, like so:

Code:

union Foo
{
    int intVal;
    float floatVal;
};

Foo bar;
bar.intVal = 0x00ABCDEF;

std::cout << "as float: " << bar.floatVal;

be warned that code like this should be avoided. The standard states that reading from any union member other than the last one written to results in undefined behavior. While in practice this will usually work and yield the expected results, there's just no guarantee and you may one day run into a compiler where this kind of code breaks.

Originally Posted by antred

If you were thinking of using unions as a convenient alternative to reinterpret_cast ...

I was actually thinking just the opposite. It the union's members are of same sized types, there is no need to use unions at all there.

As C++11 supports non POD objects inside an union, shouldn't reinterpret_cast always work, if the sizeof the union members are exactly the same ?

eg:

Code:

union foo
{
    TypeA bar;
    TypeB xip;
};// sizeof(TypeA) == sizeof(TypeB)

In the above case, shouldn't casting a TypeA object to TypeB solve the same problem more conveniently ?

To quote from C99, structs within a union that share initial common members are treated as a special case.

Originally Posted by c99

With one exception, if the value of a member of a union object is used when the most recent store to the object was to a different member, the behavior is implementation-defined.70)
One special guarantee is made in order to simplify the use of unions: If a union contains several structures that share a common initial sequence (see below), and if the union object currently contains one of these structures, it is permitted to inspect the common initial part of any of them anywhere that a declaration of the completed type of the union is visible. Two structures share a common initial sequence if corresponding members have compatible types (and, for bit-fields, the same widths) for a sequence of one or more initial members.

The example being

Code:

union {
  struct {
    int alltypes;
  }n;
  struct {
    int type;
    int intnode;
  } ni;
  struct {
    int type;
    double doublenode;
  } nf;
}u;
u.nf.type = 1;
u.nf.doublenode = 3.14;
/* ... */
if (u.n.alltypes == 1)
  if (sin(u.nf.doublenode) == 0.0)
    /* ... */

I would think that the C++ standard would inherit a similar clause.