[class.union] (original) (raw)

11 Classes [class]

11.5 Unions [class.union]

In a union, a non-static data member is activeif its name refers to an object whose lifetime has begun and has not ended ([basic.life]).

At most one of the non-static data members of an object of union type can be active at any time, that is, the value of at most one of the non-static data members can be stored in a union at any time.

[ Note

:

One special guarantee is made in order to simplify the use of unions: If a standard-layout union contains several standard-layout structs that share a common initial sequence ([class.mem]), and if a non-static data member of an object of this standard-layout union type is active and is one of the standard-layout structs, it is permitted to inspect the common initial sequence of any of the standard-layout struct members; see [class.mem].

— end note

]

The size of a union is sufficient to contain the largest of its non-static data members.

Each non-static data member is allocated as if it were the sole member of a non-union class.

[ Note

:

As a consequence, all non-static data members of a union object have the same address.

— end note

]

A union can have member functions (including constructors and destructors),but it shall not have virtual ([class.virtual]) functions.

A union shall not have base classes.

A union shall not be used as a base class.

If a union contains a non-static data member of reference type the program is ill-formed.

[ Example

:

Consider the following union:

union U { int i; float f; std::string s; };

Since std​::​string ([string.classes]) declares non-trivial versions of all of the special member functions, U will have an implicitly deleted default constructor, copy/move constructor, copy/move assignment operator, and destructor.

To use U, some or all of these member functions must be user-provided.

— end example

]

When the left operand of an assignment operator involves a member access expression ([expr.ref]) that nominates a union member, it may begin the lifetime of that union member, as described below.

For an expression E, define the set S(E)of subexpressions of Eas follows:

In an assignment expression of the form E1 = E2that uses either the built-in assignment operator ([expr.ass]) or a trivial assignment operator ([class.copy.assign]), for each element X of S(E1), if modification of X would have undefined behavior under [basic.life], an object of the type of X is implicitly created in the nominated storage; no initialization is performed and the beginning of its lifetime is sequenced after the value computation of the left and right operands and before the assignment.

[ Note

:

This ends the lifetime of the previously-active member of the union, if any ([basic.life]).

— end note

]

[ Example

:

union A { int x; int y[4]; }; struct B { A a; }; union C { B b; int k; }; int f() { C c;
c.b.a.y[3] = 4;

return c.b.a.y[3];
}

struct X { const int a; int b; }; union Y { X x; int k; }; void g() { Y y = { { 1, 2 } };
int n = y.x.a; y.k = 4;
y.x.b = n;

}

— end example

]

[ Note

:

In general, one must use explicit destructor calls and placementnew-expression to change the active member of a union.

— end note

]

[ Example

:

Consider an object u of a union type U having non-static data membersm of type M and n of type N.

If M has a non-trivial destructor and N has a non-trivial constructor (for instance, if they declare or inherit virtual functions), the active member of u can be safely switched from m ton using the destructor and placement new-expression as follows:

u.m.~M(); new (&u.n) N;

— end example

]

11.5.1 Anonymous unions [class.union.anon]

A union of the form

union { member-specification } ;

is called an anonymous union; it defines an unnamed type and an unnamed object of that type called an anonymous union object.

Nested types, anonymous unions, and functions shall not be declared within an anonymous union.

The names of the members of an anonymous union shall be distinct from the names of any other entity in the scope in which the anonymous union is declared.

For the purpose of name lookup, after the anonymous union definition, the members of the anonymous union are considered to have been defined in the scope in which the anonymous union is declared.

[ Example

:

void f() { union { int a; const char* p; }; a = 1; p = "Jennifer"; }

Here a and p are used like ordinary (non-member) variables, but since they are union members they have the same address.

— end example

]

Anonymous unions declared in a named namespace or in the global namespace shall be declared static.

Anonymous unions declared at block scope shall be declared with any storage class allowed for a block-scope variable, or with no storage class.

A storage class is not allowed in a declaration of an anonymous union in a class scope.

An anonymous union shall not have private or protected members ([class.access]).

An anonymous union shall not have member functions.

A union for which objects, pointers, or references are declared is not an anonymous union.

[ Example

:

void f() { union { int aa; char* p; } obj, *ptr = &obj; aa = 1;
ptr->aa = 1;
}

The assignment to plain aa is ill-formed since the member name is not visible outside the union, and even if it were visible, it is not associated with any particular object.

— end example

]

[ Note

:

Initialization of unions with no user-declared constructors is described in [dcl.init.aggr].

— end note

]

A union-like class is a union or a class that has an anonymous union as a direct member.

A union-like class X has a set of variant members.

If X is a union, a non-static data member of X that is not an anonymous union is a variant member of X.

In addition, a non-static data member of an anonymous union that is a member of X is also a variant member of X.

At most one variant member of a union may have a default member initializer.

[ Example

:

union U { int x = 0; union { int k; }; union { int z; int y = 1;
}; };

— end example

]