[class.union] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpxog1kmpb/{from.md → to.md} +28 -26

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

@@ -12,13 +12,13 @@ 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.
@@ -28,22 +28,20 @@ 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.
 [*Example 1*:
 Consider the following union:
@@ -55,13 +53,14 @@ union U {
 };
 ```
 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*]
 — *end note*]
@@ -78,17 +77,19 @@ 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.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*:
@@ -169,15 +170,16 @@ void f() {
 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 the scope of a namespace with external
-linkage shall be declared `static`. Anonymous unions declared at block
-scope shall be declared with any storage class allowed for a block
-variable, or with no storage class. A storage class is not allowed in a
-declaration of an anonymous union in a class scope.
 [*Note 1*:
 A union for which objects, pointers, or references are declared is not
 an anonymous union.

 [*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, the common initial
+sequence of any of the standard-layout struct members can be inspected;
+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.
 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*:
+If any non-static data member of a union has a non-trivial copy
+constructor, move constructor [[class.copy.ctor]], copy assignment
+operator, or move assignment operator [[class.copy.assign]], the
+corresponding member function of the union must be user-provided or it
+will be implicitly deleted [[dcl.fct.def.delete]] for the union.
 [*Example 1*:
 Consider the following union:
 };
 ```
 Since `std::string` [[string.classes]] declares non-trivial versions of
 all of the special member functions, `U` will have an implicitly deleted
+copy/move constructor and copy/move assignment operator. The default
+constructor and destructor of `U` are both trivial even though
+`std::string` has a non-trivial default constructor and a non-trivial
+destructor.
 — *end example*]
 — *end note*]
   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.assign]] or a trivial assignment
+operator [[class.copy.assign]], for each element `X` of S(`E1`) and each
+anonymous union member `X` [[class.union.anon]] that is a member of a
+union and has such an element as an immediate subobject (recursively),
+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*:
 Here `a` and `p` are used like ordinary (non-member) variables, but
 since they are union members they have the same address.
 — *end example*]
+An anonymous union declared in the scope of a namespace with external
+linkage shall use the *storage-class-specifier* `static`. Anonymous
+unions declared at block scope shall not use a *storage-class-specifier*
+that is not permitted in the declaration of a block variable. An
+anonymous union declaration at class scope shall not have a
+*storage-class-specifier*.
 [*Note 1*:
 A union for which objects, pointers, or references are declared is not
 an anonymous union.

Diff to HTML by rtfpessoa