>"Peter Dunker" <Pe**********@stud.tu-ilmenau.de> wrote in message
news:c6**********@piggy.rz.tu-ilmenau.de... ... Is it right that in ANSI C the union must be named inside this
kind of structure ?
[much snippage]
The example can be simplified to, e.g.:
struct S {
union {
int i;
char *cp;
};
};
In article <news:kO*****************@newsread2.news.pas.earth link.net>
xarax <xa***@email.com> writes:AFAIK, M$ VC6 gets this wrong.
I believe it is correct. Note that this can be confusing, though,
as there are *two* names omitted: the union itself has no tag --
this is the first (and unimportant) omission -- *and* the structure
member has no name. It is this second omission that causes the
problem. To see why, replace the above with:
union U { int i; char *cp; };
struct S { union U /*nothing*/; };
Note that "struct S" is now empty!
C++, Plan 9 C, and GNU C -- all three are different languages from
C and all three are different from each other -- all allow this,
however, with similar semantics. It might be nice if C99 had
adopted part of th meaning provided in these three other languages.
In those three languages, if you are defining a struct or union
such as "struct S", and you mention the name of another struct
or union without giving a field-name:
struct S { /* begin defining a new type named S */
struct T; /* import T's members */
union U; /* import U's members */
char *last; /* add a member of our own */
}; /* finish up the new type named "S" */
If the types named T and U here were previously defined as, e.g.:
struct T { double zorg; };
union U { int i; char *cp; };
then the type named S would now countain four members named "zorg",
"i", "cp", and "last", with "zorg" at offset 0 and "i" and "cp"
sharing a field in the usual manner of a union, most likley at
offset sizeof(double) (probably 8). The member "last" would be
last, most likely at offset 12 or 16 or so.
Plan 9 C goes rather further than GNU C: an "imported" sub-structure
(or sub-union, but unions are effectively just the degenerate case
of structures) adds a special "type-name-member", as it were, to
the outer structure. If an S contains a T and U as above, for
instance, and you have an actual S and functions that require a
T or a U (or pointer thereto):
struct S object;
extern void takes_a_T(struct T);
extern void takes_a_Ustar(union U *);
you can pass the object itself (or its address) to the function,
and the compiler automatically locates the embedded sub-object:
takes_a_T(object); /* passes the T part of the S */
takes_a_Ustar(&object); /* passes pointer to the U part of the S */
This gives access to one of the most useful parts of C++ without
carrying all the baggage that C++ has to lug around.
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) +1 801 277 2603
email: forget about it
http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.