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

Files changed (1) hide show

tmp/tmpmifl3opo/{from.md → to.md} +34 -28

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

@@ -1,7 +1,9 @@
 ## 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
@@ -19,27 +21,29 @@ 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:
@@ -57,10 +61,12 @@ 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:
@@ -91,32 +97,32 @@ the union, if any [[basic.life]]. — *end note*]
 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
@@ -139,20 +145,18 @@ 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() {
@@ -165,17 +169,17 @@ 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 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*:
@@ -192,11 +196,13 @@ 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 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

 ## Unions <a id="class.union">[[class.union]]</a>
+### General <a id="class.union.general">[[class.union.general]]</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
 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.
 [*Example 1*:
 Consider the following union:
 operator, and destructor. To use `U`, some or all of these member
 functions must be user-provided.
 — *end example*]
+— *end note*]
 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:
 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 cases where the above rule does not apply, the active
+member of a union can only be changed by the use of a placement
+*new-expression*. — *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
 ``` 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 member* if it is
+a non-static data member or an *anonymous union variable* otherwise.
+Each *member-declaration* in the *member-specification* of an anonymous
+union shall either define one or more public non-static data members 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 are bound in the scope inhabited by
+the union declaration.
 [*Example 1*:
 ``` cpp
 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.
 [*Example 2*:
 visible outside the union, and even if it were visible, it is not
 associated with any particular object.
 — *end example*]
+— *end note*]
+[*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

Diff to HTML by rtfpessoa