|Access||Adobe photoshop||Algoritmi||Autocad||Baze de date||C||C sharp|
|Calculatoare||Corel draw||Dot net||Excel||Fox pro||Frontpage||Hardware|
|Php||Power point||Retele calculatoare||Sql||Tutorials||Webdesign||Windows|
|Asp||Autocad||C||Dot net||Excel||Fox pro||Html||Java|
Unions don't take long to explain. They are the same as structures, except
that, where you would have written
before, now you write
Everything works the same way, but with one big exception. In a structure, the
members are allocated separate consecutive chunks of storage. In a union, every
member is allocated the same piece of storage. What would you use them for?
Well, sometimes you want a structure to contain different values of different
types at different times but to conserve space as much as possible. Using a
union, it's up to you to keep track of whatever type you put into it and make
sure that you retrieve the right type at the right time. Here's an example:
If the example had, say, put a
into the union and then extracted it as an int, a strange value would have
resulted. The two types are almost certainly not only stored differently, but
of different lengths. The
retrieved would probably be the low-order bits of the machine representation of
float, and might easily be
made up of part of the mantissa of the
plus a piece of the exponent. The Standard says that if you do this, the
behaviour is implementation defined (not undefined). The behaviour is defined
by the Standard in one case: if some of the members of a union are structures
with a ‘common initial sequence’ (the first members of each structure have
compatible type and in the case of bitfields are the same length),
and the union currently contains one of them, then the common initial part of
each can be used interchangeably. Oh good.
The C compiler does no more than work out what the biggest member in a union can be and allocates enough storage (appropriately aligned if neccessary). In particular, no checking is done to make sure that the right sort of use is made of the members. That is your task, and you'll soon find out if you get it wrong. The members of a union all start at the same address—there is guaranteed to be no padding in front of any of them.
The most common way of remembering what is in a union is to embed it in a structure, with another member of the structure used to indicate the type of thing currently in the union. Here is how it might be used:#include <stdio.h>
That also demonstrates how the dot notation is used to access structures or
unions inside other structures or unions. Some current C compilers allow you to
miss bits out of the names of embedded objects provided that they are not
ambiguous. In the example, such an unambiguous name would be
var_type.un_int and the compiler would
work out what you meant. None the less this is not permitted by the Standard.
It is because of unions that structures cannot be compared for equality. The possibility that a structure might contain a union makes it hard to compare such structures; the compiler can't tell what the union currently contains and so wouldn't know how to compare the structures. This sounds a bit hard to swallow and isn't 100% true—most structures don't contain unions—but there is also a philosophical issue at stake about just what is meant by ‘equality’ when applied to structures. Anyhow, the union business gives the Standard a good excuse to avoid the issue by not supporting structure comparison.
Politica de confidentialitate|
Adauga cod HTML in site