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

Files changed (1) hide show

tmp/tmp3m9lxnx0/{from.md → to.md} +78 -59

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

@@ -1,12 +1,12 @@
 ## Destructors <a id="class.dtor">[[class.dtor]]</a>
-A declaration of a destructor uses a function declarator ([[dcl.fct]])
-of the form
 ``` bnf
-ptr-declarator '(' parameter-declaration-clause ')' exception-specificationₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 where the *ptr-declarator* consists solely of an *id-expression*, an
 optional *attribute-specifier-seq*, and optional surrounding
 parentheses, and the *id-expression* has one of the following forms:
@@ -24,24 +24,24 @@ parentheses, and the *id-expression* has one of the following forms:
 - in a declaration at namespace scope or in a friend declaration, the
   *id-expression* is *nested-name-specifier* `~`*class-name* and the
   *class-name* names the same class as the *nested-name-specifier*.
 The *class-name* shall not be a *typedef-name*. A destructor shall take
-no arguments ([[dcl.fct]]). In a destructor declaration, each
-*decl-specifier* of the optional *decl-specifier-seq* shall be `friend`,
-`inline`, or `virtual`.
 A destructor is used to destroy objects of its class type. The address
 of a destructor shall not be taken. A destructor can be invoked for a
 `const`, `volatile` or `const` `volatile` object. `const` and `volatile`
 semantics ([[dcl.type.cv]]) are not applied on an object under
 destruction. They stop being in effect when the destructor for the most
 derived object ([[intro.object]]) starts.
-A declaration of a destructor that does not have an
-*exception-specification* is implicitly considered to have the same
-*exception-specification* as an implicit declaration ([[except.spec]]).
 If a class has no user-declared destructor, a destructor is implicitly
 declared as defaulted ([[dcl.fct.def]]). An implicitly-declared
 destructor is an `inline` `public` member of its class.
@@ -65,41 +65,41 @@ A destructor is trivial if it is not user-provided and if:
   type (or array thereof), each such class has a trivial destructor.
 Otherwise, the destructor is *non-trivial*.
 A destructor that is defaulted and not defined as deleted is *implicitly
-defined* when it is odr-used ([[basic.def.odr]]) to destroy an object
-of its class type ([[basic.stc]]) or when it is explicitly defaulted
-after its first declaration.
 Before the defaulted destructor for a class is implicitly defined, all
 the non-user-provided destructors for its base classes and its
 non-static data members shall have been implicitly defined.
 After executing the body of the destructor and destroying any automatic
 objects 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 direct base classes and, if `X` is the type of 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]]). 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. Destructors for elements of an array
-are called in reverse order of their construction (see  [[class.init]]).
 A destructor can be declared `virtual` ([[class.virtual]]) or pure
 `virtual` ([[class.abstract]]); if any objects of that class or any
 derived class are created in the program, the destructor shall be
 defined. If a class has a base class with a virtual destructor, its
 destructor (whether user- or implicitly-declared) is virtual.
-some language constructs have special semantics when used during
-destruction; see  [[class.cdtor]].
 A destructor is invoked implicitly
 - for a constructed object with static storage duration (
   [[basic.stc.static]]) at program termination ([[basic.start.term]]),
@@ -107,44 +107,50 @@ A destructor is invoked implicitly
   [[basic.stc.thread]]) at thread exit,
 - for a constructed object with automatic storage duration (
   [[basic.stc.auto]]) when the block in which an object is created
   exits ([[stmt.dcl]]),
 - for a constructed temporary object when its lifetime ends (
-  [[class.temporary]]).
 In each case, the context of the invocation is the context of the
 construction of the object. A destructor is also invoked implicitly
 through use of a *delete-expression* ([[expr.delete]]) for a
 constructed object allocated by a *new-expression* ([[expr.new]]); the
-context of the invocation is the *delete-expression*. An array of class
-type contains several subobjects for each of which the destructor is
-invoked. A destructor can also be invoked explicitly. A destructor is
-*potentially invoked* if it is invoked or as specified in  [[expr.new]]
-and  [[class.base.init]]. A program is ill-formed if a destructor that
-is potentially invoked is deleted or not accessible from the context of
-the invocation.
 At the point of definition of a virtual destructor (including an
 implicit definition ([[class.copy]])), the non-array deallocation
-function is looked up in the scope of the destructor’s class (
-[[class.member.lookup]]), and, if no declaration is found, the function
-is looked up in the global scope. If the result of this lookup is
-ambiguous or inaccessible, or if the lookup selects a placement
-deallocation function or a function with a deleted definition (
-[[dcl.fct.def]]), the program is ill-formed. This assures that a
-deallocation function corresponding to the dynamic type of an object is
-available for the *delete-expression* ([[class.free]]).
-In an explicit destructor call, the destructor name appears as 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.
-invoking `delete` on a null pointer does not call the destructor; see
-[[expr.delete]].
 ``` cpp
 struct B {
   virtual ~B() { }
 };
@@ -163,20 +169,25 @@ void f() {
   B_ptr->B_alias::~B();         // calls B's destructor
   B_ptr->B_alias::~B_alias();   // calls B's destructor
 }
 ```
-An explicit destructor call must always be written using a member access
-operator ([[expr.ref]]) or a qualified-id ([[expr.prim]]); in
-particular, the *unary-expression* `~X()` in a member function is not an
-explicit destructor call ([[expr.unary.op]]).
-explicit calls of destructors are rarely needed. One use of such calls
-is for objects placed at specific addresses using a *new-expression*
-with the placement option. 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);
@@ -190,23 +201,31 @@ void g() {                      // rare, specialized use:
   f(p);
   p->X::~X();                   // cleanup
 }
 ```
 Once a destructor is invoked for an object, the object no longer exists;
 the behavior is undefined if the destructor is invoked for an object
-whose lifetime has ended ([[basic.life]]). if the destructor for an
-automatic object 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.
-the notation for explicit call of a destructor can be used for any
 scalar type name ([[expr.pseudo]]). Allowing this makes it possible to
 write code without having to know if a destructor exists for a given
-type. For example,
 ``` cpp
 typedef int I;
 I* p;
 p->I::~I();
 ```

 ## Destructors <a id="class.dtor">[[class.dtor]]</a>
+In a declaration of a destructor, the *declarator* is a function
+declarator ([[dcl.fct]]) of the form
 ``` bnf
+ptr-declarator '(' parameter-declaration-clause ')' noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 where the *ptr-declarator* consists solely of an *id-expression*, an
 optional *attribute-specifier-seq*, and optional surrounding
 parentheses, and the *id-expression* has one of the following forms:
 - in a declaration at namespace scope or in a friend declaration, the
   *id-expression* is *nested-name-specifier* `~`*class-name* and the
   *class-name* names the same class as the *nested-name-specifier*.
 The *class-name* shall not be a *typedef-name*. A destructor shall take
+no arguments ([[dcl.fct]]). Each *decl-specifier* of the
+*decl-specifier-seq* of a destructor declaration (if any) shall be
+`friend`, `inline`, or `virtual`.
 A destructor is used to destroy objects of its class type. The address
 of a destructor shall not be taken. A destructor can be invoked for a
 `const`, `volatile` or `const` `volatile` object. `const` and `volatile`
 semantics ([[dcl.type.cv]]) are not applied on an object under
 destruction. They stop being in effect when the destructor for the most
 derived object ([[intro.object]]) starts.
+[*Note 1*: A declaration of a destructor that does not have a
+*noexcept-specifier* has the same exception specification as if had been
+implicitly declared ([[except.spec]]). — *end note*]
 If a class has no user-declared destructor, a destructor is implicitly
 declared as defaulted ([[dcl.fct.def]]). An implicitly-declared
 destructor is an `inline` `public` member of its class.
   type (or array thereof), each such class has a trivial destructor.
 Otherwise, the destructor is *non-trivial*.
 A destructor that is defaulted and not defined as deleted is *implicitly
+defined* when it is odr-used ([[basic.def.odr]]) or when it is
+explicitly defaulted after its first declaration.
 Before the defaulted destructor for a class is implicitly defined, all
 the non-user-provided destructors for its base classes and its
 non-static data members shall have been implicitly defined.
 After executing the body of the destructor and destroying any automatic
 objects 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
+type of 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]]). 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. Destructors for
+elements of an array are called in reverse order of their construction
+(see  [[class.init]]).
 A destructor can be declared `virtual` ([[class.virtual]]) or pure
 `virtual` ([[class.abstract]]); if any objects of that class or any
 derived class are created in the program, the destructor shall be
 defined. If a class has a base class with a virtual destructor, its
 destructor (whether user- or implicitly-declared) is virtual.
+[*Note 2*:  Some language constructs have special semantics when used
+during destruction; see  [[class.cdtor]]. — *end note*]
 A destructor is invoked implicitly
 - for a constructed object with static storage duration (
   [[basic.stc.static]]) at program termination ([[basic.start.term]]),
   [[basic.stc.thread]]) at thread exit,
 - for a constructed object with automatic storage duration (
   [[basic.stc.auto]]) when the block in which an object is created
   exits ([[stmt.dcl]]),
 - for a constructed temporary object when its lifetime ends (
+  [[conv.rval]], [[class.temporary]]).
 In each case, the context of the invocation is the context of the
 construction of the object. A destructor is also invoked implicitly
 through use of a *delete-expression* ([[expr.delete]]) for a
 constructed object allocated by a *new-expression* ([[expr.new]]); the
+context of the invocation is the *delete-expression*.
+[*Note 3*: An array of class type contains several subobjects for each
+of which the destructor is invoked. — *end note*]
+A destructor can also be invoked explicitly. A destructor is
+*potentially invoked* if it is invoked or as specified in  [[expr.new]],
+[[class.base.init]], and  [[except.throw]]. A program is ill-formed if a
+destructor that is potentially invoked is deleted or not accessible from
+the context of the invocation.
 At the point of definition of a virtual destructor (including an
 implicit definition ([[class.copy]])), the non-array deallocation
+function is determined as if for the expression `delete this` appearing
+in a non-virtual destructor of the destructor’s class (see
+[[expr.delete]]). If the lookup fails or if the deallocation function
+has a deleted definition ([[dcl.fct.def]]), the program is ill-formed.
+[*Note 4*: 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.
+[*Note 5*: Invoking `delete` on a null pointer does not call the
+destructor; see [[expr.delete]]. — *end note*]
+[*Example 1*:
 ``` cpp
 struct B {
   virtual ~B() { }
 };
   B_ptr->B_alias::~B();         // calls B's destructor
   B_ptr->B_alias::~B_alias();   // calls B's destructor
 }
 ```
+— *end example*]
+[*Note 6*: An explicit destructor call must always be written using a
+member access operator ([[expr.ref]]) or a *qualified-id* (
+[[expr.prim]]); in particular, the *unary-expression* `~X()` in a member
+function is not an explicit destructor call (
+[[expr.unary.op]]). — *end note*]
+[*Note 7*:
+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);
   f(p);
   p->X::~X();                   // cleanup
 }
 ```
+— *end note*]
 Once a destructor is invoked for an object, the object no longer exists;
 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 automatic object 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 8*:
+The notation for explicit call of a destructor can be used for any
 scalar type name ([[expr.pseudo]]). Allowing this makes it possible to
 write code without having to know if a destructor exists for a given
+type. For example:
 ``` cpp
 typedef int I;
 I* p;
 p->I::~I();
 ```
+— *end note*]

Diff to HTML by rtfpessoa