Unions are particularly useful in embedded programming situations where direct access to the hardware/memory is needed - because you are saving memory -. You could use a union to represent a table that stores a mixture of types in some order, you could create an array of unions that store equal-sized units, each of which can hold a variety of datatypes, a union could represent a file containing different record types, a network interface containing different request types, and so much more.

Although structs are similar to unions, the memory allocated for a union is quite different than for a struct. Every time you create an instance of a struct, the computer will lay out the fields in memory, one after the other, it allocates space for all its members separately. With a union, all the members have an offset of zero - there's one common storage space for all its members. A union is created with enough space for its largest field, the programmer then decides which value will be stored there. If you a union called quantity - for example -, with fields called count, weight and volume, whether you set the count, weight or volume field, the data will go into the same space in memory.

Source: studytonight.com

Let's suppose you want to keep track of a quantity of something, it might be a count, a weight or a volume. You could create a structure like this:

  struct fruit {
    short count;
    float weight;
    float volume;
  };

There are a few reasons why this is not a good idea:

• It will take up more space in memory.

• Someone might set more than one value.

• There's nothing called quantity.

A union should be used in this situations. You could specify something called quantity in a datatype, you can decide for each particular piece of data whether you are going to record a count, a weight or a volume against it.

Even though unions are similar to structures, they are used for entirely different situations:

• You should use a structure when your construct should be a group of other things.

• You should use a union when your construct can be one of many different things but only one at a time.

• Unions are typically used in situations where space is premium, but more importantly, for exclusively alternate data.

• Unions ensure that mutually exclusive states remain mutually exclusive.

• Unions share a common storage space where structures store several datatypes simultaneously, for example, a structure can hold an int, and a dobule and a char, whereas a union can hold an int, or a double, or a char.

Let's look at an example:

  union _data {
    int i;
    float f;
    char str[20];
  } data;

The above does not declare `data' to contain three distinct members called `i', `f' and `str', it defines `data' to contain a single member that is either `i', `f' or `str'.

A variable of type `_data' can store an integer, a floating-point number of a string of characters, a single variable (same memory location) can be used to store multiple types of data.

The memory occupied by a union will be large enough to hold the largest member of the union, any variable of type `_data' will occupy 20 bytes of memory, because this is the maximum space which can be occupied by a character string.

When a union is defined, it creates a user-defined type, it doesn't allocate memory for it. To allocate memory for a given union type and work with it, we need to create variables.

A union can be defined to contain as many members as you want, and they can be the members of a structure (they can even be arrays). Pointers to unions can also be declared, their syntax and rules for performing operations are the same as for structures.