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

Files changed (1) hide show

tmp/tmpxd7yrvoa/{from.md → to.md} +37 -26

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

@@ -21,12 +21,12 @@ parentheses, and the *id-expression* has one of the following forms:
   `~`*class-name* and the *class-name* is the injected-class-name of the
   class nominated by the *nested-name-specifier*.
 A prospective destructor shall take no arguments [[dcl.fct]]. Each
 *decl-specifier* of the *decl-specifier-seq* of a prospective destructor
-declaration (if any) shall be `friend`, `inline`, `virtual`,
-`constexpr`, or `consteval`.
 If a class has no user-declared prospective destructor, a prospective
 destructor is implicitly declared as defaulted [[dcl.fct.def]]. An
 implicitly-declared prospective destructor is an inline public member of
 its class.
@@ -59,33 +59,39 @@ when the destructor for the most derived object [[intro.object]] starts.
 [*Note 2*: A declaration of a destructor that does not have a
 *noexcept-specifier* has the same exception specification as if it had
 been implicitly declared [[except.spec]]. — *end note*]
-A defaulted destructor for a class `X` is defined as deleted if:
-- `X` is a union-like class that has a variant member with a non-trivial
- destructor,
-- any potentially constructed subobject has class type `M` (or array
- thereof) and `M` has a deleted destructor or a destructor that is
-  inaccessible from the defaulted destructor,
-- or, for a virtual destructor, lookup of the non-array deallocation
   function results in an ambiguity or in a function that is deleted or
   inaccessible from the defaulted destructor.
-A destructor is trivial if it is not user-provided and if:
 - the destructor is not virtual,
-- all of the direct base classes of its class have trivial destructors,
-  and
-- for all of the non-static data members of its class that are of class
- type (or array thereof), each such class has a trivial destructor.
 Otherwise, the destructor is *non-trivial*.
-A defaulted destructor is a constexpr destructor if it is
-constexpr-suitable [[dcl.constexpr]].
 Before a defaulted destructor for a class is implicitly defined, all the
 non-user-provided destructors for its base classes and its non-static
 data members are implicitly defined.
@@ -98,17 +104,18 @@ created in the program, the destructor shall be defined.
 during destruction; see  [[class.cdtor]]. — *end note*]
 After executing the body of the destructor and destroying any objects
 with automatic storage duration allocated within the body, a destructor
 for class `X` calls the destructors for `X`’s direct non-variant
-non-static data members, the destructors for `X`’s non-virtual direct
-base classes and, if `X` is the most derived class [[class.base.init]],
-its destructor calls the destructors for `X`’s virtual base classes. All
-destructors are called as if they were referenced with a qualified name,
-that is, ignoring any possible virtual overriding destructors in more
-derived classes. Bases and members are destroyed in the reverse order of
-the completion of their constructor (see  [[class.base.init]]).
 [*Note 4*: A `return` statement [[stmt.return]] in a destructor might
 not directly return to the caller; before transferring control to the
 caller, the destructors for the members and bases are
 called. — *end note*]
@@ -154,11 +161,11 @@ lookup fails or if the deallocation function has a deleted definition
 [*Note 6*: This assures that a deallocation function corresponding to
 the dynamic type of an object is available for the *delete-expression*
 [[class.free]]. — *end note*]
 In an explicit destructor call, the destructor is specified by a `~`
-followed by a *type-name* or *decltype-specifier* that denotes the
 destructor’s class type. The invocation of a destructor is subject to
 the usual rules for member functions [[class.mfct]]; that is, if the
 object is not of the destructor’s class type and not of a class derived
 from the destructor’s class type (including when the destructor is
 invoked via a null pointer value), the program has undefined behavior.
@@ -201,11 +208,13 @@ member function is not an explicit destructor call
 Explicit calls of destructors are rarely needed. One use of such calls
 is for objects placed at specific addresses using a placement
 *new-expression*. Such use of explicit placement and destruction of
 objects can be necessary to cope with dedicated hardware resources and
-for writing memory management facilities. For example,
 ``` cpp
 void* operator new(std::size_t, void* p) { return p; }
 struct X {
   X(int);
@@ -219,17 +228,19 @@ void g() {                      // rare, specialized use:
   f(p);
   p->X::~X();                   // cleanup
 }
 ```
 — *end note*]
 Once a destructor is invoked for an object, the object’s lifetime ends;
 the behavior is undefined if the destructor is invoked for an object
 whose lifetime has ended [[basic.life]].
-[*Example 2*: If the destructor for an object with automatic storage
 duration is explicitly invoked, and the block is subsequently left in a
 manner that would ordinarily invoke implicit destruction of the object,
 the behavior is undefined. — *end example*]
 [*Note 10*:

   `~`*class-name* and the *class-name* is the injected-class-name of the
   class nominated by the *nested-name-specifier*.
 A prospective destructor shall take no arguments [[dcl.fct]]. Each
 *decl-specifier* of the *decl-specifier-seq* of a prospective destructor
+declaration (if any) shall be `friend`, `inline`, `virtual`, or
+`constexpr`.
 If a class has no user-declared prospective destructor, a prospective
 destructor is implicitly declared as defaulted [[dcl.fct.def]]. An
 implicitly-declared prospective destructor is an inline public member of
 its class.
 [*Note 2*: A declaration of a destructor that does not have a
 *noexcept-specifier* has the same exception specification as if it had
 been implicitly declared [[except.spec]]. — *end note*]
+A defaulted destructor for a class `X` is defined as deleted if
+- `X` is a non-union class and any non-variant potentially constructed
+ subobject has class type `M` (or possibly multidimensional array
+  thereof) where `M` has a destructor that is deleted or is inaccessible
+ from the defaulted destructor,
+- `X` is a union and
+ - overload resolution to select a constructor to default-initialize an
+    object of type `X` either fails or selects a constructor that is
+    either deleted or not trivial, or
+  - `X` has a variant member `V` of class type `M` (or possibly
+    multi-dimensional array thereof) where `V` has a default member
+    initializer and `M` has a destructor that is non-trivial, or,
+- for a virtual destructor, lookup of the non-array deallocation
   function results in an ambiguity or in a function that is deleted or
   inaccessible from the defaulted destructor.
+A destructor for a class `X` is trivial if it is not user-provided and
+if
 - the destructor is not virtual,
+- all of the direct base classes of `X` have trivial destructors, and
+- either `X` is a union or for all of the non-variant non-static data
+  members of `X` that are of class type (or array thereof), each such
+  class has a trivial destructor.
 Otherwise, the destructor is *non-trivial*.
+A defaulted destructor is a constexpr destructor.
 Before a defaulted destructor for a class is implicitly defined, all the
 non-user-provided destructors for its base classes and its non-static
 data members are implicitly defined.
 during destruction; see  [[class.cdtor]]. — *end note*]
 After executing the body of the destructor and destroying any objects
 with automatic storage duration allocated within the body, a destructor
 for class `X` calls the destructors for `X`’s direct non-variant
+non-static data members other than anonymous unions, the destructors for
+`X`’s non-virtual direct base classes and, if `X` is the most derived
+class [[class.base.init]], its destructor calls the destructors for
+`X`’s virtual base classes. All destructors are called as if they were
+referenced with a qualified name, that is, ignoring any possible virtual
+overriding destructors in more derived classes. Bases and members are
+destroyed in the reverse order of the completion of their constructor
+(see  [[class.base.init]]).
 [*Note 4*: A `return` statement [[stmt.return]] in a destructor might
 not directly return to the caller; before transferring control to the
 caller, the destructors for the members and bases are
 called. — *end note*]
 [*Note 6*: This assures that a deallocation function corresponding to
 the dynamic type of an object is available for the *delete-expression*
 [[class.free]]. — *end note*]
 In an explicit destructor call, the destructor is specified by a `~`
+followed by a *type-name* or *computed-type-specifier* that denotes the
 destructor’s class type. The invocation of a destructor is subject to
 the usual rules for member functions [[class.mfct]]; that is, if the
 object is not of the destructor’s class type and not of a class derived
 from the destructor’s class type (including when the destructor is
 invoked via a null pointer value), the program has undefined behavior.
 Explicit calls of destructors are rarely needed. One use of such calls
 is for objects placed at specific addresses using a placement
 *new-expression*. Such use of explicit placement and destruction of
 objects can be necessary to cope with dedicated hardware resources and
+for writing memory management facilities.
+[*Example 2*:
 ``` cpp
 void* operator new(std::size_t, void* p) { return p; }
 struct X {
   X(int);
   f(p);
   p->X::~X();                   // cleanup
 }
 ```
+— *end example*]
 — *end note*]
 Once a destructor is invoked for an object, the object’s lifetime ends;
 the behavior is undefined if the destructor is invoked for an object
 whose lifetime has ended [[basic.life]].
+[*Example 3*: If the destructor for an object with automatic storage
 duration is explicitly invoked, and the block is subsequently left in a
 manner that would ordinarily invoke implicit destruction of the object,
 the behavior is undefined. — *end example*]
 [*Note 10*:

Diff to HTML by rtfpessoa