C Programming

There are no disadvantages as such. This is really no different to choosing between using a float or an integral type. Each is intended for a specific purpose so there's really no point looking for disadvantages of one over the other. It's far better to simply look at the purpose for which each was intended and decide which to use according to your needs.

A structure is an aggregate of two or more members where every member has its own address and may be accessed independently of the other members (changing the value of one member does not affect any other members). The members of a union, however, share the same memory address and thus only one value may be stored in a union at any given moment.

The size of a union is equal to the largest member of that union, plus any padding bytes required to bring the total size up to the nearest word boundary (typically a 4-byte boundary on a 32-bit machine). The size of a structure, however, is equal to the sum of its member sizes plus any padding bytes require to align the individual members as well as the structure itself. In memory-restricted systems, it is best to declare members in order of size, largest first, to conserve memory.

Basically, you use a structure as you would a database record, to group related data elements as a single entity, such as a person's name, their address, telephone number and other contact details when creating a list of contacts.

You use a union when you need to be able to store two or more different types of information but only require access to one specific type at a time. For instance, if a piece of data can either be referred to by name or by number, but never both, a union makes sense as you don't waste memory allocating storage for two separate pieces of data when you only actually require one value in memory at any given moment.

Note that the relationship between the data stored in a union and the member that was used to write that data purely conventional. It is entirely up to the programmer to keep track of which member was last used to write the data and thus read back that data correctly. Although it is an error to write through one member and subsequently read through another, it is not illegal. However, such code should be treated with suspicion:

"Unions are often misused for 'type conversion'. This misuse is practiced mainly by programmers trained in languages that do not have explicit type conversion facilities, so that cheating is necessary. For example, the following "converts" an int to int* simply by assuming bitwise equivalence:

union Fudge {

int i;

int* p;

};

int* cheat (int i) {

Fudge a;

a.i = i;

return a.p; // bad use

}

"This is not really a conversion at all. On some machines, an int and an int* do not occupy the same amount of space, while on others, no integer can have an odd address. Such use of a union is dangerous and non-portable." [Bjarne Stroustrup, The C++ Programming Language, Fourth Edition].

In order to use a union correctly, it is often necessary to use a "type field" to keep track of the active member. Both the type field and the union it relates to are typically declared as members of the same structure, thus making the relationship between the data and its type more concrete. For instance, if a piece of data can be represented by a string or by an integer (a name or a number), we might use the following enum, union and structure:

typedef enum type_field {name, number};

typedef union my_union_t {

char* pstr;

int num;

} my_union;

typedef struct my_struct_t {

type_field type;

my_union data;

} my_struct;

Whenever we need to write to the my_struct.data member, we first change the my_struct.type member to the appropriate type (name or number), and then write to my_struct.data.pstr or my_struct.data.int as appropriate. when we wish to read back the data, we test the my_struct.type member and then read back the appropriate member of my_struct.data.

Note that although it may seem we are using just a much memory as we would with a structure alone, by virtue of the use a type field, we'd still have to use a type field if we used a structure instead of a union because we'd still need to know which member was "active", even if those members did not share a memory address.

Although unions can be essential for compactness of data and performance, most programs don't improve much from the use of unions and unions are somewhat error-prone due to the onus being on the programmer to ensure data is read correctly. In C++, many of the advantages of a union can also be rendered moot by the used of derived classes, however we can also encapsulate a union within a class and thus shift the onus of responsibility to the class itself, thereby ensuring data is always interpreted correctly.