Casting to union

Question

Having limited experience with unions in C++, I am struggling to understand the basic mechanics of casting to/from that datatype.

Suppose two types Type_a and Type_b are wrappers of type int and long respectively.

A union is defined as:

union Type_u {
    Type_a a;
    Type_b b;
}

Now I have something of type Type_a, lets call it j (Just to be confusing). I need to pass it to a function that expects a parameter of type Type_u:

void burninate(Type_u peasants);

What is the proper way to pass this variable j to burninate? (I've run into issues casting j to Type_u as well as passing it in as-is. Neither compiled.)

It may be worth pointing out that I have no ability to modify the union type (or Type_a or Type_b or burninate's signature for that matter.)

Answer 1

Since Type_a is the first element, you can initialize a union like this:

Type_a j;
Type_u u = {j};
burninate(u);

If you want to pass a type of Type_b:

Type_b k;
Type_u u;
u.b = k;
burninate(u);

There is a difference on this in C and C++. In C99, you can use designated initializer to initialize elements that isn't the first.

Type_b k;
Type_u u = {.b = k};
burninate(u);

Answer 2

You can pass j just like this ((Type_u)j) and it will work.

[EDIT] As the guys showed disbelief, here is the code sample Try to compile this code, it will work like a charm.

#include <stdio.h>
typedef union type_u {
    int a;
    long b;
}type;

int main ()
{
type T;
int j = 10;

    T = ((type)j);

    printf ("T.a:%d T.b:%lu \n", T.a, T.b);

return 0;
}

See the o/p XXX-mac:~ jork$ gcc union_test.c XXX-mac:~ jork$ ./a.out T.a:10 T.b:10

Answer 3

C++ does not generally go out of its way to encourage the use of unions, and it can be particularly awkward if union members have non-trivial constructors and destructors, since in that case the union's own constructor (destructor, respectively) will be deleted and you'll have to provide one yourself if you need one (which you generally do).

On the whole, it's probably not a great idea to put non-POD types into a union, since the semantics are awkward; in general, you cannot assign a value to an object which has not been constructed, and, while you could use placement new to construct a member of a union, you would have no way to actually know that the member hadn't been previously constructed. Furthermore, if a member has an explicit and non-trivial destructor, you could provide an explicit destructor for the union, which could explicitly call the member's destructor, but how would it know whether it had to do that or not?

If your union members are POD, though, you're fine, but you still cannot cast the union to a member or a member type to the union. (GCC allows this as a C extension, but afaik g++ does not extend C++ in the same way.)

Still, there is nothing stopping you from giving the union a constructor. For example:

union long_or_double {
  long a;
  double d;

  long_or_double(long l) : a(l) {}
  long_or_double(int i) : a(i) {}
  // etc.
  long_or_double(double d) : d(d) {}
};

int f(long_or_double u);

int main(int argc, char** argv) {
  // Both of these work, because there is an explicit constructor
  f(argc);
  f(3.7);
  // ...
}

If you cannot add constructors to the definition of the union type, I think the best you can do is to define a make_union function, overriding it appropriately for each member type.

Answer 4

Unions work exactly like structs (the only difference is the way objects are allocated in memory). So you have Type_u U; Type_a j; U.a = j; burninate(U);