kraus@uiucdcsb.UUCP (03/01/87)
Anonymous unions are nice. For example, page 67 of the C++ book
gives the following example:
struct entry {
char* name;
char type;
union {
char* string_value; // used if type=='s'
int int_value; // used if type=='i'
};
};
If "x" is an "entry", then one can get to the fields in the union
with "x.string_value" and "x.int_value". (In C, one would have to
give the union a name, which is annoying.)
But why aren't there anonymous structures, too? For example, suppose
that for some reason I also needed a flag in case type=='i'. I would
like to say
union {
char* string_value;
struct { int int_value; int flag; };
};
But this does not seem to be allowed. (I believe that it was version 1.1
that I tried this on.) So, I am forced to put "int flag" at the top level
of the structure, which is annoying. It gets worse when lots of cases
need several fields. The clearest solution that I have found is to have
several anonymous unions in succession.
It also seems the me that adding anonymous structures would increase the
orthogonality of the language.
Tim Kraus
Department of Computer Science
University of Illinois at Urbana-Champaign
1304 West Stringfield Avenue
Urbana, IL 61801
USENET: {pur-ee,convex,ihnp4}!uiucdcs!kraus
ARPA: kraus@b.cs.uiuc.edu
CSNET: kraus%uiuc@csnet-relayroger@valid.UUCP (03/12/87)
We (Valid Logic Systems, Inc.) have modified our 1.1 C++ translator to
allow anonymous structures as well as anonymous unions. Our primary motivation
for this enhancement was for use with our Pascal-to-C++ translator that we
are developing. In Pascal there is a construct known as a "variant record"
that takes the following form (from Jensen & Wirth, 2nd Edition, pp. 42 & 45):
<record type> ::= record <field list> end
<field list> ::= <fixed part> | <fixed part> ; <variant part> | <variant part>
<fixed part> ::= <record section> { ; <record section>}
<record section> ::= <field identifier> {, <field identifier>} : <type>|<empty>
<variant part> ::= case <tag field> <type identifier> of <variant> {; <variant>}
<variant> ::= <case label list> : ( <field list> ) | <empty>
<case label list> ::= <case label> {, <case label>}
<case label> ::= <constant>
<tag field> ::= <identifier> : | <empty>
Thus, one can have types such as:
variant_record_example = record
a: integer;
case boolean of
FALSE: (b, c, d: integer; e: real);
TRUE: (f: array [0 .. 10] of char; g: random_type_name)
end;
var q: variant_record_example;
begin
q.a := 1;
q.b := 2;
q.e := 3.0;
<etc.>
where all of the names of the various variant and non-variant fields are in
the same scope. The "equivalent" type in C would look like:
typedef struct {
int a;
union {
struct {
int b, c, d; float e;
} _pointless_name_1;
struct {
char f[11]; random_type_name g;
} _pointless_name_2;
} _pointless_name_3;
} variant_record_example;
variant_record_example q;
q.a = 1;
q._pointless_name_3._pointless_name_1.b = 2;
q._pointless_name_3._pointless_name_1.e = 3;
<etc.>
Standard C++ allows you to eliminate _pointless_name_3, but still requires
_pointless_name_1 and _pointless_name_2. Our extension allows you to declare
this type as:
typedef struct {
int a;
union {
struct {
int b, c, d; float e;
};
struct {
char f[11]; random_type_name g;
};
};
} variant_record_example;
Once you have anonymous structures AND unions you begin to see their more
abstract function, which is to group a collection of variables for storage
allocation purposes; a struct allocates them in series and a union allocates
them in parallel. Naming a struct or union then becomes merely a scope issue,
allowing you to create many simultaneous, independent name spaces for
variables.
I have discussed this issue with Bjarne and he said that he is considering
adopting this change in the standard. Others who believe it is a useful
generalization might want to drop Bjarne a line to that effect.
Roger H. Scott
Valid Logic Systems, Inc.
2820 Orchard Parkway
San Jose, CA 95134
(408) 432-9400 x2484len@geac.UUCP (Leonard Vanek) (03/16/87)
In article <1062@valid.UUCP> roger@valid.UUCP (Roger H. Scott) writes: >We (Valid Logic Systems, Inc.) have modified our 1.1 C++ translator to >allow anonymous structures as well as anonymous unions. Our primary motivation >for this enhancement was for use with our Pascal-to-C++ translator that we >are developing. In Pascal there is a construct known as a "variant record" >that takes the following form (from Jensen & Wirth, 2nd Edition, pp. 42 & 45): > He then goes on to explain the need for the following syntax for emulating a pascal variant record: > >typedef struct { > int a; > union { > struct { > int b, c, d; float e; > }; > struct { > char f[11]; random_type_name g; > }; > }; >} variant_record_example; This is certainly the minimal change to achieve the desired result and may be preferred for precisely that reason. However, it strikes me that if what is wanted is a way to get variant records in C++ (not just for Pascal to C translators but also for original code) why not look for a way to eliminate all of the redundant syntax to come up with a clean ``variant structure'' mechanism? Perhaps it could be modelled on the switch statement in much the same way that Pascal and Ada model their variant records on their case statements? I have not thought this idea out so it may not be all that good, but as long as Bjarne and other readers of this newsgroup are considering the small change maybe you should consider the larger one as well. --------------------------------------------------------------------- Leonard Vanek phone (416) 475-0525 Geac Computers International 350 Steelcase Rd. West Markham Ontario L3R 1B3 Canada UUCP ... {allegra,ihnp4,decvax,pyramid} !utzoo!yetti!geac!len