[class.union] - C++14 → C++17

Files changed (1) hide show

tmp/tmprcj0tuxg/{from.md → to.md} +145 -45

tmp/tmprcj0tuxg/{from.md → to.md} RENAMED Viewed

@@ -1,31 +1,46 @@
 ## Unions <a id="class.union">[[class.union]]</a>
-In a union, at most one of the non-static data members 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. 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 an object of this standard-layout
-union type contains one of the standard-layout structs, it is permitted
-to inspect the common initial sequence of any of standard-layout struct
-members; see  [[class.mem]]. 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 struct. All
-non-static data members of a union object have the same address.
 A union can have member functions (including constructors and
-destructors), but not 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. If any non-static data member of a union has a
-non-trivial default constructor ([[class.ctor]]), copy constructor (
-[[class.copy]]), move constructor ([[class.copy]]), copy assignment
-operator ([[class.copy]]), move assignment operator ([[class.copy]]),
-or destructor ([[class.dtor]]), the corresponding member function of
-the union must be user-provided or it will be implicitly deleted (
-[[dcl.fct.def.delete]]) for the union.
 Consider the following union:
 ``` cpp
 union U {
@@ -39,84 +54,169 @@ 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.
-In general, one must use explicit destructor calls and placement new
-operators to change the active member of a union. Consider an object `u`
-of a `union` type `U` having non-static data members `m` 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` to `n` using the destructor and placement new operator as follows:
 ``` cpp
 u.m.~M();
 new (&u.n) N;
 ```
 A union of the form
-is called an *anonymous union*; it defines an unnamed object of unnamed
-type. The *member-specification* of an anonymous union shall only define
-non-static data members. Nested types, anonymous unions, and functions
-cannot 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.
 ``` cpp
 void f() {
   union { int a; const char* p; };
   a = 1;
   p = "Jennifer";
 }
 ```
-Here `a` and `p` are used like ordinary (nonmember) variables, but since
-they are union members they have the same address.
 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 (Clause
-[[class.access]]). An anonymous union shall not have function members.
 A union for which objects, pointers, or references are declared is not
 an anonymous union.
 ``` cpp
 void f() {
   union { int aa; char* p; } obj, *ptr = &obj;
   aa = 1;           // error
   ptr->aa = 1;      // OK
 }
 ```
 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. Initialization of unions with no
-user-declared constructors is described in ([[dcl.init.aggr]]).
 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
-*brace-or-equal-initializer*.
 ``` cpp
 union U {
   int x = 0;
-  union { };
   union {
     int z;
     int y = 1;      // error: initialization for second variant member of U
   };
 };
 ```

 ## Unions <a id="class.union">[[class.union]]</a>
+In a union, a non-static data member is *active* if 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 1*: 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 struct.
+[*Note 2*: A union object and its non-static data members are
+pointer-interconvertible ([[basic.compound]], [[expr.static.cast]]). 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.
+[*Note 3*: Absent default member initializers ([[class.mem]]), if any
+non-static data member of a union has a non-trivial default
+constructor ([[class.ctor]]), copy constructor ([[class.copy]]), move
+constructor ([[class.copy]]), copy assignment operator (
+[[class.copy]]), move assignment operator ([[class.copy]]), or
+destructor ([[class.dtor]]), the corresponding member function of the
+union must be user-provided or it will be implicitly deleted (
+[[dcl.fct.def.delete]]) for the union. — *end note*]
+[*Example 1*:
 Consider the following union:
 ``` cpp
 union U {
 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 `E` as follows:
+- If `E` is of the form `A.B`, S(E) contains the elements of S(A), and
+  also contains `A.B` if `B` names a union member of a non-class,
+  non-array type, or of a class type with a trivial default constructor
+  that is not deleted, or an array of such types.
+- If `E` is of the form `A[B]` and is interpreted as a built-in array
+  subscripting operator, S(E) is S(A) if `A` is of array type, S(B) if
+  `B` is of array type, and empty otherwise.
+- Otherwise, S(E) is empty.
+In an assignment expression of the form `E1 = E2` that uses either the
+built-in assignment operator ([[expr.ass]]) or a trivial assignment
+operator ([[class.copy]]), 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 4*: This ends the lifetime of the previously-active member of
+the union, if any ([[basic.life]]). — *end note*]
+[*Example 2*:
+``` cpp
+union A { int x; int y[4]; };
+struct B { A a; };
+union C { B b; int k; };
+int f() {
+  C c;                  // does not start lifetime of any union member
+  c.b.a.y[3] = 4;       // OK: S(c.b.a.y[3]) contains c.b and c.b.a.y;
+                        // creates objects to hold union members c.b and c.b.a.y
+  return c.b.a.y[3];    // OK: c.b.a.y refers to newly created object (see [basic.life])
+}
+struct X { const int a; int b; };
+union Y { X x; int k; };
+void g() {
+  Y y = { { 1, 2 } };   // OK, y.x is active union member ([class.mem])
+  int n = y.x.a;
+  y.k = 4;              // OK: ends lifetime of y.x, y.k is active member of union
+  y.x.b = n;            // undefined behavior: y.x.b modified outside its lifetime,
+                        // S(y.x.b) is empty because X's default constructor is deleted,
+                        // so union member y.x's lifetime does not implicitly start
+}
+```
+— *end example*]
+[*Note 5*: In general, one must use explicit destructor calls and
+placement *new-expression* to change the active member of a
+union. — *end note*]
+[*Example 3*:
+Consider an object `u` of a `union` type `U` having non-static data
+members `m` 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` to `n` using the destructor and placement
+*new-expression* as follows:
 ``` cpp
 u.m.~M();
 new (&u.n) N;
 ```
+— *end example*]
+### Anonymous unions <a id="class.union.anon">[[class.union.anon]]</a>
 A union of the form
+is called an *anonymous union*; it defines an unnamed type and an
+unnamed object of that type called an *anonymous union object*. Each
+*member-declaration* in the *member-specification* of an anonymous union
+shall either define a non-static data member or be a
+*static_assert-declaration*.
+[*Note 1*: Nested types, anonymous unions, and functions cannot be
+declared within an anonymous union. — *end note*]
+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 1*:
 ``` cpp
 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 (Clause
+[[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 2*:
 ``` cpp
 void f() {
   union { int aa; char* p; } obj, *ptr = &obj;
   aa = 1;           // error
   ptr->aa = 1;      // OK
 }
 ```
 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 2*: 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 3*:
 ``` cpp
 union U {
   int x = 0;
+  union {
+    int k;
+  };
   union {
     int z;
     int y = 1;      // error: initialization for second variant member of U
   };
 };
 ```
+— *end example*]

Diff to HTML by rtfpessoa