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

Files changed (1) hide show

tmp/tmp52x3luf4/{from.md → to.md} +41 -39

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

@@ -1,44 +1,45 @@
 ## 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:
@@ -48,21 +49,21 @@ union U {
   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 `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
@@ -71,20 +72,20 @@ the lifetime of that union member, as described below. For an expression
   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]; };
@@ -98,11 +99,11 @@ int f() {
 }
 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
@@ -133,24 +134,25 @@ new (&u.n) N;
 ### 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() {
@@ -168,12 +170,12 @@ 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 member functions.
 A union for which objects, pointers, or references are declared is not
 an anonymous union.
 [*Example 2*:
@@ -190,11 +192,11 @@ 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

 ## Unions <a id="class.union">[[class.union]]</a>
+A *union* is a class defined with the *class-key* `union`.
 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 non-union class.
 [*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.default.ctor]], copy constructor, move constructor
+[[class.copy.ctor]], copy assignment operator, move assignment operator
+[[class.copy.assign]], 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:
   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 `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
   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.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 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 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
 ### Anonymous unions <a id="class.union.anon">[[class.union.anon]]</a>
 A union of the form
+``` bnf
+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*. 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*. 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 1*:
 ``` cpp
 void f() {
 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 2*:
 visible outside the union, and even if it were visible, it is not
 associated with any particular object.
 — *end example*]
+[*Note 1*: 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

Diff to HTML by rtfpessoa