[special] - C++11 → C++14

Files changed (1) hide show

tmp/tmpid3heaz2/{from.md → to.md} +283 -253

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

@@ -5,12 +5,14 @@ assignment operator ([[class.copy]]), move constructor and move
 assignment operator ([[class.copy]]), and destructor ([[class.dtor]])
 are *special member functions*. The implementation will implicitly
 declare these member functions for some class types when the program
 does not explicitly declare them. The implementation will implicitly
 define them if they are odr-used ([[basic.def.odr]]). See
-[[class.ctor]], [[class.dtor]] and  [[class.copy]]. Programs shall not
-define implicitly-declared special member functions.
 Programs may explicitly refer to implicitly-declared special member
 functions. a program may explicitly call, take the address of or form a
 pointer to member to an implicitly-declared special member function.
@@ -32,22 +34,44 @@ implicitly.
 Special member functions obey the usual access rules (Clause
 [[class.access]]). declaring a constructor `protected` ensures that only
 derived classes and friends can create objects using it.
 ## Constructors <a id="class.ctor">[[class.ctor]]</a>
-Constructors do not have names. A special declarator syntax is used to
-declare or define the constructor. The syntax uses:
-- an optional *decl-specifier-seq* in which each *decl-specifier* is
-  either a *function-specifier* or `constexpr`,
-- the constructor’s class name, and
-- a parameter list
-in that order. In such a declaration, optional parentheses around the
-constructor class name are ignored.
 ``` cpp
 struct S {
   S();              // declares the constructor
 };
@@ -60,21 +84,15 @@ constructors do not have names, they are never found during name lookup;
 however an explicit type conversion using the functional notation (
 [[expr.type.conv]]) will cause a constructor to be called to initialize
 an object. For initialization of objects of class type see
 [[class.init]].
-A *typedef-name* shall not be used as the *class-name* in the
-*declarator-id* for a constructor declaration.
-A constructor shall not be `virtual` ([[class.virtual]]) or `static` (
-[[class.static]]). A constructor can be invoked for a `const`,
-`volatile` or `const` `volatile` object. A constructor shall not be
-declared `const`, `volatile`, or `const` `volatile` ([[class.this]]).
-`const` and `volatile` semantics ([[dcl.type.cv]]) are not applied on
-an object under construction. They come into effect when the constructor
-for the most derived object ([[intro.object]]) ends. A constructor
-shall not be declared with a *ref-qualifier*.
 A *default* constructor for a class `X` is a constructor of class `X`
 that can be called without an argument. If there is no user-declared
 constructor for class `X`, a constructor having no parameters is
 implicitly declared as defaulted ([[dcl.fct.def]]). An
@@ -91,19 +109,19 @@ as deleted if:
   user-provided default constructor,
 - `X` is a union and all of its variant members are of const-qualified
   type (or array thereof),
 - `X` is a non-union class and all members of any anonymous union member
   are of const-qualified type (or array thereof),
-- any direct or virtual base class, or non-static data member with no
-  *brace-or-equal-initializer*, has class type `M` (or array thereof)
-  and either `M` has no default constructor or overload resolution (
-  [[over.match]]) as applied to `M`’s default constructor results in an
-  ambiguity or in a function that is deleted or inaccessible from the
-  defaulted default constructor, or
-- any direct or virtual base class or non-static data member has a type
- with a destructor that is deleted or inaccessible from the defaulted
- default constructor.
 A default constructor is trivial if it is not user-provided and if:
 - its class has no virtual functions ([[class.virtual]]) and no virtual
   base classes ([[class.mi]]), and
@@ -149,16 +167,11 @@ accessible (Clause  [[class.access]]).
 [[class.base.init]] describes the order in which constructors for base
 classes and non-static data members are called and describes how
 arguments can be specified for the calls to these constructors.
-A copy constructor ([[class.copy]]) is used to copy objects of class
-type. A move constructor ([[class.copy]]) is used to move the contents
-of objects of class type.
-No return type (not even `void`) shall be specified for a constructor. A
-`return` statement in the body of a constructor shall not specify a
 return value. The address of a constructor shall not be taken.
 A functional notation type conversion ([[expr.type.conv]]) can be used
 to create new objects of its type. The syntax looks like an explicit
 call of the constructor.
@@ -203,23 +216,21 @@ void no_opt(C* cptr) {
 Temporaries of class type are created in various contexts: binding a
 reference to a prvalue ([[dcl.init.ref]]), returning a prvalue (
 [[stmt.return]]), a conversion that creates a prvalue ([[conv.lval]],
 [[expr.static.cast]], [[expr.const.cast]], [[expr.cast]]), throwing an
-exception ([[except.throw]]), entering a *handler* (
-[[except.handle]]), and in some initializations ([[dcl.init]]). The
-lifetime of exception objects is described in  [[except.throw]]. Even
-when the creation of the temporary object is unevaluated (Clause
-[[expr]]) or otherwise avoided ([[class.copy]]), all the semantic
-restrictions shall be respected as if the temporary object had been
-created and later destroyed. even if there is no call to the destructor
-or copy/move constructor, all the semantic restrictions, such as
-accessibility (Clause  [[class.access]]) and whether the function is
-deleted ([[dcl.fct.def.delete]]), shall be satisfied. However, in the
-special case of a function call used as the operand of a
-*decltype-specifier* ([[expr.call]]), no temporary is introduced, so
-the foregoing does not apply to the prvalue of any such function call.
 Consider the following code:
 ``` cpp
 class X {
@@ -280,18 +291,18 @@ point than the end of the full-expression. The first context is when a
 default constructor is called to initialize an element of an array. If
 the constructor has one or more default arguments, the destruction of
 every temporary created in a default argument is sequenced before the
 construction of the next array element, if any.
-The second context is when a reference is bound to a temporary. The
 temporary to which the reference is bound or the temporary that is the
 complete object of a subobject to which the reference is bound persists
 for the lifetime of the reference except:
 - A temporary bound to a reference member in a constructor’s
-  ctor-initializer ([[class.base.init]]) persists until the constructor
-  exits.
 - A temporary bound to a reference parameter in a function call (
   [[expr.call]]) persists until the completion of the full-expression
   containing the call.
 - The lifetime of a temporary bound to the returned value in a function
   return statement ([[stmt.return]]) is not extended; the temporary is
@@ -340,21 +351,21 @@ the expression `S(16) + S(23)` creates three temporaries: a first
 temporary `T1` to hold the result of the expression `S(16)`, a second
 temporary `T2` to hold the result of the expression `S(23)`, and a third
 temporary `T3` to hold the result of the addition of these two
 expressions. The temporary `T3` is then bound to the reference `cr`. It
 is unspecified whether `T1` or `T2` is created first. On an
-implementation where `T1` is created before `T2`, it is guaranteed that
-`T2` is destroyed before `T1`. The temporaries `T1` and `T2` are bound
-to the reference parameters of `operator+`; these temporaries are
-destroyed at the end of the full-expression containing the call to
-`operator+`. The temporary `T3` bound to the reference `cr` is destroyed
-at the end of `cr`’s lifetime, that is, at the end of the program. In
-addition, the order in which `T3` is destroyed takes into account the
-destruction order of other objects with static storage duration. That
-is, because `obj1` is constructed before `T3`, and `T3` is constructed
-before `obj2`, it is guaranteed that `obj2` is destroyed before `T3`,
-and that `T3` is destroyed before `obj1`.
 ## Conversions <a id="class.conv">[[class.conv]]</a>
 Type conversions of class objects can be specified by constructors and
 by conversion functions. These conversions are called *user-defined
@@ -418,17 +429,19 @@ its class. Such a constructor is called a *converting constructor*.
 ``` cpp
 struct X {
     X(int);
     X(const char*, int =0);
 };
 void f(X arg) {
   X a = 1;          // a = X(1)
   X b = "Jessie";   // b = X("Jessie",0)
   a = 2;            // a = X(2)
   f(3);             // f(X(3))
 }
 ```
 An explicit constructor constructs objects just like non-explicit
 constructors, but does so only where the direct-initialization syntax (
@@ -439,19 +452,21 @@ value-initialization ([[dcl.init]]).
 ``` cpp
 struct Z {
   explicit Z();
   explicit Z(int);
 };
 Z a;                            // OK: default-initialization performed
 Z a1 = 1;                       // error: no implicit conversion
 Z a3 = Z(1);                    // OK: direct initialization syntax used
 Z a2(1);                        // OK: direct initialization syntax used
 Z* p = new Z(1);                // OK: direct initialization syntax used
 Z a4 = (Z)1;                    // OK: explicit cast used
 Z a5 = static_cast<Z>(1);       // OK: explicit cast used
 ```
 A non-explicit copy/move constructor ([[class.copy]]) is a converting
 constructor. An implicitly-declared copy/move constructor is not an
 explicit constructor; it may be called for implicit type conversions.
@@ -482,11 +497,11 @@ return type can be specified. If a conversion function is a member
 function, the type of the conversion function ([[dcl.fct]]) is
 “function taking no parameter returning *conversion-type-id*”. A
 conversion function is never used to convert a (possibly cv-qualified)
 object to the (possibly cv-qualified) same object type (or a reference
 to it), to a (possibly cv-qualified) base class of that type (or a
-reference to it), or to (possibly cv-qualified) void.[^1]
 ``` cpp
 struct X {
   operator int();
 };
@@ -547,29 +562,46 @@ Conversion functions can be virtual.
 Conversion functions cannot be declared `static`.
 ## Destructors <a id="class.dtor">[[class.dtor]]</a>
-A special declarator syntax using an optional *function-specifier* (
-[[dcl.fct.spec]]) followed by `~` followed by the destructor’s class
-name followed by an empty parameter list is used to declare the
-destructor in a class definition. In such a declaration, the `~`
-followed by the destructor’s class name can be enclosed in optional
-parentheses; such parentheses are ignored. A *typedef-name* shall not be
-used as the *class-name* following the `~` in the declarator for a
-destructor declaration.
-A destructor is used to destroy objects of its class type. A destructor
-takes no parameters, and no return type can be specified for it (not
-even `void`). The address of a destructor shall not be taken. A
-destructor shall not be `static`. A destructor can be invoked for a
-`const`, `volatile` or `const` `volatile` object. A destructor shall not
-be declared `const`, `volatile` or `const` `volatile` ([[class.this]]).
-`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
-destructor shall not be declared with a *ref-qualifier*.
 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]]).
@@ -579,15 +611,13 @@ destructor is an `inline` `public` member of its class.
 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 of the non-static data members has class type `M` (or array
   thereof) and `M` has a deleted destructor or a destructor that is
   inaccessible from the defaulted destructor,
-- any direct or virtual base class 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:
@@ -631,30 +661,33 @@ 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]].
-Destructors are invoked implicitly
-- for constructed objects with static storage duration (
   [[basic.stc.static]]) at program termination ([[basic.start.term]]),
-- for constructed objects with thread storage duration (
   [[basic.stc.thread]]) at thread exit,
-- for constructed objects with automatic storage duration (
   [[basic.stc.auto]]) when the block in which an object is created
   exits ([[stmt.dcl]]),
-- for constructed temporary objects when the lifetime of a temporary
- object ends ([[class.temporary]]),
-- for constructed objects allocated by a *new-expression* (
-  [[expr.new]]), through use of a *delete-expression* (
-  [[expr.delete]]),
-- in several situations due to the handling of exceptions (
-  [[except.handle]]).
-A program is ill-formed if an object of class type or array thereof is
-declared and the destructor for the class is not accessible at the point
-of the declaration. Destructors can also be invoked explicitly.
 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
@@ -666,14 +699,16 @@ 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, the program has undefined behavior
-(except that invoking `delete` on a null pointer has no effect).
 ``` cpp
 struct B {
   virtual ~B() { }
 };
@@ -763,28 +798,23 @@ void foo(int i) {
 When an object is deleted with a *delete-expression* ([[expr.delete]]),
 a *deallocation function* (`operator delete()` for non-array objects or
 `operator delete[]()` for arrays) is (implicitly) called to reclaim the
 storage occupied by the object ([[basic.stc.dynamic.deallocation]]).
-If a *delete-expression* begins with a unary `::` operator, the
-deallocation function’s name is looked up in global scope. Otherwise, if
-the *delete-expression* is used to deallocate a class object whose
 static type has a virtual destructor, the deallocation function is the
 one selected at the point of definition of the dynamic type’s virtual
-destructor ([[class.dtor]]).[^2] Otherwise, if the *delete-expression*
 is used to deallocate an object of class `T` or array thereof, the
 static and dynamic types of the object shall be identical and the
 deallocation function’s name is looked up in the scope of `T`. If this
-lookup fails to find the name, the name is looked up in the global
-scope. If the result of the lookup is ambiguous or inaccessible, or if
-the lookup selects a placement deallocation function, the program is
-ill-formed.
-When a *delete-expression* is executed, the selected deallocation
-function shall be called with the address of the block of storage to be
-reclaimed as its first argument and (if the two-parameter style is used)
-the size of the block as its second argument.[^3]
 Any deallocation function for a class `X` is a static member (even if
 not explicitly declared `static`).
 ``` cpp
@@ -901,13 +931,12 @@ complex d = sqrt(b,c);          // call sqrt(complex,complex)
 complex e;                      // initialize by a call of
                                 // complex()
 complex f = 3;                  // construct complex(3) using
                                 // complex(double)
                                 // copy/move it into f
-complex g = { 1, 2 };           // construct complex(1, 2)
-                                // using complex(double, double)
-                                // and copy/move it into g
 ```
 overloading of the assignment operator ([[over.ass]]) has no effect on
 initialization.
@@ -958,11 +987,11 @@ ctor-initializer:
 ```
 ``` bnf
 mem-initializer-list:
     mem-initializer '...'ₒₚₜ
-    mem-initializer ',' mem-initializer-list '...'ₒₚₜ
 ```
 ``` bnf
 mem-initializer:
     mem-initializer-id '(' expression-listₒₚₜ ')'
@@ -1060,31 +1089,39 @@ full-expression. Any expression in a *mem-initializer* is evaluated as
 part of the full-expression that performs the initialization. A
 *mem-initializer* where the *mem-initializer-id* denotes a virtual base
 class is ignored during execution of a constructor of any class that is
 not the most derived class.
-In a non-delegating constructor, if a given non-static data member or
-base class is not designated by a *mem-initializer-id* (including the
 case where there is no *mem-initializer-list* because the constructor
-has no *ctor-initializer*) and the entity is not a virtual base class of
-an abstract class ([[class.abstract]]), then
 - if the entity is a non-static data member that has a
-  *brace-or-equal-initializer*, the entity is initialized as specified
- in  [[dcl.init]];
-- otherwise, if the entity is a variant member ([[class.union]]), no
-  initialization is performed;
 - otherwise, the entity is default-initialized ([[dcl.init]]).
 An abstract class ([[class.abstract]]) is never a most derived class,
 thus its constructors never initialize virtual base classes, therefore
 the corresponding *mem-initializer*s may be omitted. An attempt to
 initialize more than one non-static data member of a union renders the
-program ill-formed. After the call to a constructor for class `X` has
-completed, if a member of `X` is neither initialized nor given a value
-during execution of the *compound-statement* of the body of the
-constructor, the member has indeterminate value.
 ``` cpp
 struct A {
   A();
 };
@@ -1117,10 +1154,16 @@ struct A {
 the `A(int)` constructor will simply initialize `i` to the value of
 `arg`, and the side effects in `i`’s *brace-or-equal-initializer* will
 not take place.
 In a non-delegating constructor, initialization proceeds in the
 following order:
 - First, and only for the constructor of the most derived class (
   [[intro.object]]), virtual base classes are initialized in the order
@@ -1508,59 +1551,35 @@ If the class definition does not explicitly declare a copy constructor,
 one is declared *implicitly*. If the class definition declares a move
 constructor or move assignment operator, the implicitly declared copy
 constructor is defined as deleted; otherwise, it is defined as
 defaulted ([[dcl.fct.def]]). The latter case is deprecated if the class
 has a user-declared copy assignment operator or a user-declared
-destructor. Thus, for the class definition
-``` cpp
-struct X {
-  X(const X&, int);
-};
-```
-a copy constructor is implicitly-declared. If the user-declared
-constructor is later defined as
-``` cpp
-X::X(const X& x, int i =0) { /* ... */ }
-```
-then any use of `X`’s copy constructor is ill-formed because of the
-ambiguity; no diagnostic is required.
 The implicitly-declared copy constructor for a class `X` will have the
 form
 ``` cpp
 X::X(const X&)
 ```
-if
-- each direct or virtual base class `B` of `X` has a copy constructor
-  whose first parameter is of type `const` `B&` or `const` `volatile`
-  `B&`, and
-- for all the non-static data members of `X` that are of a class type
-  `M` (or array thereof), each such class type has a copy constructor
-  whose first parameter is of type `const` `M&` or `const` `volatile`
-  `M&`.[^4]
-Otherwise, the implicitly-declared copy constructor will have the form
 ``` cpp
 X::X(X&)
 ```
 If the definition of a class `X` does not explicitly declare a move
 constructor, one will be implicitly declared as defaulted if and only if
 - `X` does not have a user-declared copy constructor,
 - `X` does not have a user-declared copy assignment operator,
-- `X` does not have a user-declared move assignment operator,
-- `X` does not have a user-declared destructor, and
-- the move constructor would not be implicitly defined as deleted.
 When the move constructor is not implicitly declared or explicitly
 supplied, expressions that otherwise would have invoked the move
 constructor may instead invoke a copy constructor.
@@ -1575,56 +1594,54 @@ An implicitly-declared copy/move constructor is an `inline` `public`
 member of its class. A defaulted copy/move constructor for a class `X`
 is defined as deleted ([[dcl.fct.def.delete]]) if `X` has:
 - a variant member with a non-trivial corresponding constructor and `X`
   is a union-like class,
-- a non-static data member of class type `M` (or array thereof) that
   cannot be copied/moved because overload resolution ([[over.match]]),
   as applied to `M`’s corresponding constructor, results in an ambiguity
   or a function that is deleted or inaccessible from the defaulted
   constructor,
-- a direct or virtual base class `B` that cannot be copied/moved because
- overload resolution ([[over.match]]), as applied to `B`’s
-  corresponding constructor, results in an ambiguity or a function that
-  is deleted or inaccessible from the defaulted constructor,
-- any direct or virtual base class or non-static data member of a type
-  with a destructor that is deleted or inaccessible from the defaulted
-  constructor,
 - for the copy constructor, a non-static data member of rvalue reference
-  type, or
-- for the move constructor, a non-static data member or direct or
-  virtual base class with a type that does not have a move constructor
-  and is not trivially copyable.
 A copy/move constructor for class `X` is trivial if it is not
-user-provided and if
 - class `X` has no virtual functions ([[class.virtual]]) and no virtual
   base classes ([[class.mi]]), and
 - the constructor selected to copy/move each direct base class subobject
   is trivial, and
 - for each non-static data member of `X` that is of class type (or array
   thereof), the constructor selected to copy/move that member is
   trivial;
 otherwise the copy/move constructor is *non-trivial*.
 A copy/move constructor that is defaulted and not defined as deleted is
-*implicitly defined* if it is odr-used ([[basic.def.odr]]) to
-initialize an object of its class type from a copy of an object of its
-class type or of a class type derived from its class type[^5] or when it
 is explicitly defaulted after its first declaration. The copy/move
 constructor is implicitly defined even if the implementation elided its
 odr-use ([[basic.def.odr]], [[class.temporary]]). If the
 implicitly-defined constructor would satisfy the requirements of a
 `constexpr` constructor ([[dcl.constexpr]]), the implicitly-defined
 constructor is `constexpr`.
 Before the defaulted copy/move constructor for a class is implicitly
-defined, all non-user-provided copy/move constructors for its direct and
-virtual base classes and its non-static data members shall have been
-implicitly defined. An implicitly-declared copy/move constructor has an
 *exception-specification* ([[except.spec]]).
 The implicitly-defined copy/move constructor for a non-union class `X`
 performs a memberwise copy/move of its bases and members.
 *brace-or-equal-initializer*s of non-static data members are ignored.
@@ -1650,11 +1667,11 @@ The implicitly-defined copy/move constructor for a union `X` copies the
 object representation ([[basic.types]]) of `X`.
 A user-declared *copy* assignment operator `X::operator=` is a
 non-static non-template member function of class `X` with exactly one
 parameter of type `X`, `X&`, `const` `X&`, `volatile` `X&` or `const`
-`volatile` `X&`.[^6] An overloaded assignment operator must be declared
 to have only one parameter; see  [[over.ass]]. More than one form of
 copy assignment operator may be declared for a class. If a class `X`
 only has a copy assignment operator with a parameter of type `X&`, an
 expression of type const `X` cannot be assigned to an object of type
 `X`.
@@ -1689,11 +1706,11 @@ if
 - each direct base class `B` of `X` has a copy assignment operator whose
   parameter is of type `const` `B&`, `const` `volatile` `B&` or `B`, and
 - for all the non-static data members of `X` that are of a class type
   `M` (or array thereof), each such class type has a copy assignment
   operator whose parameter is of type `const` `M&`, `const` `volatile`
-  `M&` or `M`.[^7]
 Otherwise, the implicitly-declared copy assignment operator will have
 the form
 ``` cpp
@@ -1711,14 +1728,12 @@ If the definition of a class `X` does not explicitly declare a move
 assignment operator, one will be implicitly declared as defaulted if and
 only if
 - `X` does not have a user-declared copy constructor,
 - `X` does not have a user-declared move constructor,
-- `X` does not have a user-declared copy assignment operator,
-- `X` does not have a user-declared destructor, and
-- the move assignment operator would not be implicitly defined as
-  deleted.
 The class definition
 ``` cpp
 struct S {
@@ -1758,24 +1773,18 @@ deleted if `X` has:
 - a variant member with a non-trivial corresponding assignment operator
   and `X` is a union-like class, or
 - a non-static data member of `const` non-class type (or array thereof),
   or
 - a non-static data member of reference type, or
-- a non-static data member of class type `M` (or array thereof) that
-  cannot be copied/moved because overload resolution ([[over.match]]),
-  as applied to `M`’s corresponding assignment operator, results in an
-  ambiguity or a function that is deleted or inaccessible from the
-  defaulted assignment operator, or
-- a direct or virtual base class `B` that cannot be copied/moved because
-  overload resolution ([[over.match]]), as applied to `B`’s
-  corresponding assignment operator, results in an ambiguity or a
-  function that is deleted or inaccessible from the defaulted assignment
-  operator, or
-- for the move assignment operator, a non-static data member or direct
-  base class with a type that does not have a move assignment operator
-  and is not trivially copyable, or any direct or indirect virtual base
-  class.
 Because a copy/move assignment operator is implicitly declared for a
 class if not declared by the user, a base class copy/move assignment
 operator is always hidden by the corresponding assignment operator of a
 derived class ([[over.ass]]). A *using-declaration* (
@@ -1786,27 +1795,38 @@ declaration of such an operator and does not suppress the implicit
 declaration of the derived class operator; the operator introduced by
 the *using-declaration* is hidden by the implicitly-declared operator in
 the derived class.
 A copy/move assignment operator for class `X` is trivial if it is not
-user-provided and if
 - class `X` has no virtual functions ([[class.virtual]]) and no virtual
   base classes ([[class.mi]]), and
 - the assignment operator selected to copy/move each direct base class
   subobject is trivial, and
 - for each non-static data member of `X` that is of class type (or array
   thereof), the assignment operator selected to copy/move that member is
   trivial;
 otherwise the copy/move assignment operator is *non-trivial*.
-A copy/move assignment operator that is defaulted and not defined as
-deleted is *implicitly defined* when it is odr-used ([[basic.def.odr]])
-(e.g., when it is selected by overload resolution to assign to an object
-of its class type) or when it is explicitly defaulted after its first
-declaration.
 Before the defaulted copy/move assignment operator for a class is
 implicitly defined, all non-user-provided copy/move assignment operators
 for its direct base classes and its non-static data members shall have
 been implicitly defined. An implicitly-declared copy/move assignment
@@ -1857,19 +1877,20 @@ member function is not accessible (Clause  [[class.access]]).
 Copying/moving one object into another using the copy/move constructor
 or the copy/move assignment operator does not change the layout or size
 of either object.
 When certain criteria are met, an implementation is allowed to omit the
-copy/move construction of a class object, even if the copy/move
-constructor and/or destructor for the object have side effects. In such
-cases, the implementation treats the source and target of the omitted
-copy/move operation as simply two different ways of referring to the
-same object, and the destruction of that object occurs at the later of
-the times when the two objects would have been destroyed without the
-optimization.[^8] This elision of copy/move operations, called *copy
-elision*, is permitted in the following circumstances (which may be
-combined to eliminate multiple copies):
 - in a `return` statement in a function with a class return type, when
   the expression is the name of a non-volatile automatic object (other
   than a function or catch-clause parameter) with the same
   cv-unqualified type as the function return type, the copy/move
@@ -1886,14 +1907,15 @@ combined to eliminate multiple copies):
   same cv-unqualified type, the copy/move operation can be omitted by
   constructing the temporary object directly into the target of the
   omitted copy/move
 - when the of an exception handler (Clause  [[except]]) declares an
   object of the same type (except for cv-qualification) as the exception
-  object ([[except.throw]]), the copy/move operation can be omitted by
   treating the as an alias for the exception object if the meaning of
   the program will be unchanged except for the execution of constructors
-  and destructors for the object declared by the .
 ``` cpp
 class Thing {
 public:
   Thing();
@@ -1917,22 +1939,25 @@ function `f()` and the copying of that temporary object into object
 viewed as directly initializing the global object `t2`, and that
 object’s destruction will occur at program exit. Adding a move
 constructor to `Thing` has the same effect, but it is the move
 construction from the temporary object to `t2` that is elided.
-When the criteria for elision of a copy operation are met or would be
-met save for the fact that the source object is a function parameter,
-and the object to be copied is designated by an lvalue, overload
-resolution to select the constructor for the copy is first performed as
-if the object were designated by an rvalue. If overload resolution
-fails, or if the type of the first parameter of the selected constructor
-is not an rvalue reference to the object’s type (possibly cv-qualified),
-overload resolution is performed again, considering the object as an
-lvalue. This two-stage overload resolution must be performed regardless
-of whether copy elision will occur. It determines the constructor to be
-called if elision is not performed, and the selected constructor must be
-accessible even if the call is elided.
 ``` cpp
 class Thing {
 public:
   Thing();
@@ -1977,29 +2002,33 @@ as follows:
 The *constructor characteristics* of a constructor or constructor
 template are
 - the template parameter list ([[temp.param]]), if any,
 - the *parameter-type-list* ([[dcl.fct]]),
-- the *exception-specification* ([[except.spec]]),
 - absence or presence of `explicit` ([[class.conv.ctor]]), and
 - absence or presence of `constexpr` ([[dcl.constexpr]]).
 For each non-template constructor in the candidate set of inherited
 constructors other than a constructor having no parameters or a
 copy/move constructor having a single parameter, a constructor is
 implicitly declared with the same constructor characteristics unless
 there is a user-declared constructor with the same signature in the
-class where the *using-declaration* appears. Similarly, for each
-constructor template in the candidate set of inherited constructors, a
-constructor template is implicitly declared with the same constructor
-characteristics unless there is an equivalent user-declared constructor
-template ([[temp.over.link]]) in the class where the using-declaration
-appears. Default arguments are not inherited.
 A constructor so declared has the same access as the corresponding
 constructor in `X`. It is deleted if the corresponding constructor in
-`X` is deleted ([[dcl.fct.def]]).
 Default and copy/move constructors may be implicitly declared as
 specified in  [[class.ctor]] and  [[class.copy]].
 ``` cpp
@@ -2142,10 +2171,11 @@ while writing a message to the standard log whenever an object of class
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.types]: basic.md#basic.types
 [class.abstract]: class.md#class.abstract
 [class.access]: class.md#class.access
 [class.base.init]: #class.base.init
 [class.cdtor]: #class.cdtor
 [class.conv]: #class.conv
@@ -2154,19 +2184,19 @@ while writing a message to the standard log whenever an object of class
 [class.copy]: #class.copy
 [class.ctor]: #class.ctor
 [class.dtor]: #class.dtor
 [class.expl.init]: #class.expl.init
 [class.free]: #class.free
 [class.inhctor]: #class.inhctor
 [class.init]: #class.init
 [class.mem]: class.md#class.mem
 [class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
 [class.mi]: class.md#class.mi
-[class.static]: class.md#class.static
 [class.temporary]: #class.temporary
-[class.this]: class.md#class.this
 [class.union]: class.md#class.union
 [class.virtual]: class.md#class.virtual
 [conv]: conv.md#conv
 [conv.lval]: conv.md#conv.lval
 [dcl.array]: dcl.md#dcl.array
@@ -2181,11 +2211,11 @@ while writing a message to the standard log whenever an object of class
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
 [dcl.type.cv]: dcl.md#dcl.type.cv
 [diff.special]: compatibility.md#diff.special
 [except]: except.md#except
-[except.handle]: except.md#except.handle
 [except.spec]: except.md#except.spec
 [except.throw]: except.md#except.throw
 [expr]: expr.md#expr
 [expr.ass]: expr.md#expr.ass
 [expr.call]: expr.md#expr.call
@@ -2208,52 +2238,52 @@ while writing a message to the standard log whenever an object of class
 [over.best.ics]: over.md#over.best.ics
 [over.ics.ref]: over.md#over.ics.ref
 [over.load]: over.md#over.load
 [over.match]: over.md#over.match
 [over.match.best]: over.md#over.match.best
 [special]: #special
 [stmt.dcl]: stmt.md#stmt.dcl
 [stmt.return]: stmt.md#stmt.return
 [temp.over.link]: temp.md#temp.over.link
 [temp.param]: temp.md#temp.param
 [temp.variadic]: temp.md#temp.variadic
-[^1]: These conversions are considered as standard conversions for the
     purposes of overload resolution ([[over.best.ics]],
     [[over.ics.ref]]) and therefore initialization ([[dcl.init]]) and
     explicit casts ([[expr.static.cast]]). A conversion to `void` does
     not invoke any conversion function ([[expr.static.cast]]). Even
     though never directly called to perform a conversion, such
     conversion functions can be declared and can potentially be reached
     through a call to a virtual conversion function in a base class.
-[^2]: A similar provision is not needed for the array version of
     `operator` `delete` because  [[expr.delete]] requires that in this
     situation, the static type of the object to be deleted be the same
     as its dynamic type.
-[^3]: If the static type of the object to be deleted is different from
-    the dynamic type and the destructor is not virtual the size might be
-    incorrect, but that case is already undefined; see  [[expr.delete]].
 [^4]: This implies that the reference parameter of the
     implicitly-declared copy constructor cannot bind to a `volatile`
     lvalue; see  [[diff.special]].
-[^5]: See  [[dcl.init]] for more details on direct and copy
-    initialization.
-[^6]: Because a template assignment operator or an assignment operator
     taking an rvalue reference parameter is never a copy assignment
     operator, the presence of such an assignment operator does not
     suppress the implicit declaration of a copy assignment operator.
     Such assignment operators participate in overload resolution with
     other assignment operators, including copy assignment operators,
     and, if selected, will be used to assign an object.
-[^7]: This implies that the reference parameter of the
     implicitly-declared copy assignment operator cannot bind to a
     `volatile` lvalue; see  [[diff.special]].
-[^8]: Because only one object is destroyed instead of two, and one
     copy/move constructor is not executed, there is still one object
     destroyed for each one constructed.

 assignment operator ([[class.copy]]), and destructor ([[class.dtor]])
 are *special member functions*. The implementation will implicitly
 declare these member functions for some class types when the program
 does not explicitly declare them. The implementation will implicitly
 define them if they are odr-used ([[basic.def.odr]]). See
+[[class.ctor]], [[class.dtor]] and  [[class.copy]]. An
+implicitly-declared special member function is declared at the closing
+`}` of the *class-specifier*. Programs shall not define
+implicitly-declared special member functions.
 Programs may explicitly refer to implicitly-declared special member
 functions. a program may explicitly call, take the address of or form a
 pointer to member to an implicitly-declared special member function.
 Special member functions obey the usual access rules (Clause
 [[class.access]]). declaring a constructor `protected` ensures that only
 derived classes and friends can create objects using it.
+For a class, its non-static data members, its non-virtual direct base
+classes, and, if the class is not abstract ([[class.abstract]]), its
+virtual base classes are called its *potentially constructed
+subobjects*.
 ## Constructors <a id="class.ctor">[[class.ctor]]</a>
+Constructors do not have names. A declaration of a constructor 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:
+- in a *member-declaration* that belongs to the *member-specification*
+  of a class but is not a friend declaration ([[class.friend]]), the
+  *id-expression* is the injected-class-name (Clause  [[class]]) of the
+  immediately-enclosing class;
+- in a *member-declaration* that belongs to the *member-specification*
+  of a class template but is not a friend declaration, the
+  *id-expression* is a *class-name* that names the current
+  instantiation ([[temp.dep.type]]) of the immediately-enclosing class
+  template; or
+- in a declaration at namespace scope or in a friend declaration, the
+  *id-expression* is a *qualified-id* that names a constructor (
+  [[class.qual]]).
+The *class-name* shall not be a *typedef-name*. In a constructor
+declaration, each *decl-specifier* in the optional *decl-specifier-seq*
+shall be `friend`, `inline`, `explicit`, or `constexpr`.
 ``` cpp
 struct S {
   S();              // declares the constructor
 };
 however an explicit type conversion using the functional notation (
 [[expr.type.conv]]) will cause a constructor to be called to initialize
 an object. For initialization of objects of class type see
 [[class.init]].
+A constructor 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 construction. They come into effect
+when the constructor for the most derived object ([[intro.object]])
+ends.
 A *default* constructor for a class `X` is a constructor of class `X`
 that can be called without an argument. If there is no user-declared
 constructor for class `X`, a constructor having no parameters is
 implicitly declared as defaulted ([[dcl.fct.def]]). An
   user-provided default constructor,
 - `X` is a union and all of its variant members are of const-qualified
   type (or array thereof),
 - `X` is a non-union class and all members of any anonymous union member
   are of const-qualified type (or array thereof),
+- any potentially constructed subobject, except for a non-static data
+ member with a *brace-or-equal-initializer*, has class type `M` (or
+ array thereof) and either `M` has no default constructor or overload
+ resolution ([[over.match]]) as applied to `M`’s default constructor
+ results in an ambiguity or in a function that is deleted or
+ inaccessible from the defaulted default constructor, or
+- any potentially constructed subobject has a type with a destructor
+  that is deleted or inaccessible from the defaulted default
+  constructor.
 A default constructor is trivial if it is not user-provided and if:
 - its class has no virtual functions ([[class.virtual]]) and no virtual
   base classes ([[class.mi]]), and
 [[class.base.init]] describes the order in which constructors for base
 classes and non-static data members are called and describes how
 arguments can be specified for the calls to these constructors.
+A `return` statement in the body of a constructor shall not specify a
 return value. The address of a constructor shall not be taken.
 A functional notation type conversion ([[expr.type.conv]]) can be used
 to create new objects of its type. The syntax looks like an explicit
 call of the constructor.
 Temporaries of class type are created in various contexts: binding a
 reference to a prvalue ([[dcl.init.ref]]), returning a prvalue (
 [[stmt.return]]), a conversion that creates a prvalue ([[conv.lval]],
 [[expr.static.cast]], [[expr.const.cast]], [[expr.cast]]), throwing an
+exception ([[except.throw]]), and in some initializations (
+[[dcl.init]]). The lifetime of exception objects is described in
+[[except.throw]]. Even when the creation of the temporary object is
+unevaluated (Clause  [[expr]]) or otherwise avoided ([[class.copy]]),
+all the semantic restrictions shall be respected as if the temporary
+object had been created and later destroyed. This includes
+accessibility ([[class.access]]) and whether it is deleted, for the
+constructor selected and for the destructor. However, in the special
+case of a function call used as the operand of a *decltype-specifier* (
+[[expr.call]]), no temporary is introduced, so the foregoing does not
+apply to the prvalue of any such function call.
 Consider the following code:
 ``` cpp
 class X {
 default constructor is called to initialize an element of an array. If
 the constructor has one or more default arguments, the destruction of
 every temporary created in a default argument is sequenced before the
 construction of the next array element, if any.
+The second context is when a reference is bound to a temporary.[^1] The
 temporary to which the reference is bound or the temporary that is the
 complete object of a subobject to which the reference is bound persists
 for the lifetime of the reference except:
 - A temporary bound to a reference member in a constructor’s
+ *ctor-initializer* ([[class.base.init]]) persists until the
+ constructor exits.
 - A temporary bound to a reference parameter in a function call (
   [[expr.call]]) persists until the completion of the full-expression
   containing the call.
 - The lifetime of a temporary bound to the returned value in a function
   return statement ([[stmt.return]]) is not extended; the temporary is
 temporary `T1` to hold the result of the expression `S(16)`, a second
 temporary `T2` to hold the result of the expression `S(23)`, and a third
 temporary `T3` to hold the result of the addition of these two
 expressions. The temporary `T3` is then bound to the reference `cr`. It
 is unspecified whether `T1` or `T2` is created first. On an
+implementation where `T1` is created before `T2`, `T2` shall be
+destroyed before `T1`. The temporaries `T1` and `T2` are bound to the
+reference parameters of `operator+`; these temporaries are destroyed at
+the end of the full-expression containing the call to `operator+`. The
+temporary `T3` bound to the reference `cr` is destroyed at the end of
+`cr`’s lifetime, that is, at the end of the program. In addition, the
+order in which `T3` is destroyed takes into account the destruction
+order of other objects with static storage duration. That is, because
+`obj1` is constructed before `T3`, and `T3` is constructed before
+`obj2`, `obj2` shall be destroyed before `T3`, and `T3` shall be
+destroyed before `obj1`.
 ## Conversions <a id="class.conv">[[class.conv]]</a>
 Type conversions of class objects can be specified by constructors and
 by conversion functions. These conversions are called *user-defined
 ``` cpp
 struct X {
     X(int);
     X(const char*, int =0);
+    X(int, int);
 };
 void f(X arg) {
   X a = 1;          // a = X(1)
   X b = "Jessie";   // b = X("Jessie",0)
   a = 2;            // a = X(2)
   f(3);             // f(X(3))
+  f({1, 2});        // f(X(1,2))
 }
 ```
 An explicit constructor constructs objects just like non-explicit
 constructors, but does so only where the direct-initialization syntax (
 ``` cpp
 struct Z {
   explicit Z();
   explicit Z(int);
+  explicit Z(int, int);
 };
 Z a;                            // OK: default-initialization performed
 Z a1 = 1;                       // error: no implicit conversion
 Z a3 = Z(1);                    // OK: direct initialization syntax used
 Z a2(1);                        // OK: direct initialization syntax used
 Z* p = new Z(1);                // OK: direct initialization syntax used
 Z a4 = (Z)1;                    // OK: explicit cast used
 Z a5 = static_cast<Z>(1);       // OK: explicit cast used
+Z a6 = { 3, 4 };                // error: no implicit conversion
 ```
 A non-explicit copy/move constructor ([[class.copy]]) is a converting
 constructor. An implicitly-declared copy/move constructor is not an
 explicit constructor; it may be called for implicit type conversions.
 function, the type of the conversion function ([[dcl.fct]]) is
 “function taking no parameter returning *conversion-type-id*”. A
 conversion function is never used to convert a (possibly cv-qualified)
 object to the (possibly cv-qualified) same object type (or a reference
 to it), to a (possibly cv-qualified) base class of that type (or a
+reference to it), or to (possibly cv-qualified) void.[^2]
 ``` cpp
 struct X {
   operator int();
 };
 Conversion functions cannot be declared `static`.
 ## 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:
+- in a *member-declaration* that belongs to the *member-specification*
+  of a class but is not a friend declaration ([[class.friend]]), the
+  *id-expression* is `~`*class-name* and the *class-name* is the
+  injected-class-name (Clause  [[class]]) of the immediately-enclosing
+  class;
+- in a *member-declaration* that belongs to the *member-specification*
+  of a class template but is not a friend declaration, the
+  *id-expression* is `~`*class-name* and the *class-name* names the
+  current instantiation ([[temp.dep.type]]) of the
+  immediately-enclosing class template; or
+- 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]]).
 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:
 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]]),
+- for a constructed object with thread storage duration (
   [[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
 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() { }
 };
 When an object is deleted with a *delete-expression* ([[expr.delete]]),
 a *deallocation function* (`operator delete()` for non-array objects or
 `operator delete[]()` for arrays) is (implicitly) called to reclaim the
 storage occupied by the object ([[basic.stc.dynamic.deallocation]]).
+Class-specific deallocation function lookup is a part of general
+deallocation function lookup ([[expr.delete]]) and occurs as follows.
+If the *delete-expression* is used to deallocate a class object whose
 static type has a virtual destructor, the deallocation function is the
 one selected at the point of definition of the dynamic type’s virtual
+destructor ([[class.dtor]]).[^3] Otherwise, if the *delete-expression*
 is used to deallocate an object of class `T` or array thereof, the
 static and dynamic types of the object shall be identical and the
 deallocation function’s name is looked up in the scope of `T`. If this
+lookup fails to find the name, general deallocation function lookup (
+[[expr.delete]]) continues. If the result of the lookup is ambiguous or
+inaccessible, or if the lookup selects a placement deallocation
+function, the program is ill-formed.
 Any deallocation function for a class `X` is a static member (even if
 not explicitly declared `static`).
 ``` cpp
 complex e;                      // initialize by a call of
                                 // complex()
 complex f = 3;                  // construct complex(3) using
                                 // complex(double)
                                 // copy/move it into f
+complex g = { 1, 2 };           // initialize by a call of
+                                // complex(double, double)
 ```
 overloading of the assignment operator ([[over.ass]]) has no effect on
 initialization.
 ```
 ``` bnf
 mem-initializer-list:
     mem-initializer '...'ₒₚₜ
+    mem-initializer '...'ₒₚₜ ',' mem-initializer-list
 ```
 ``` bnf
 mem-initializer:
     mem-initializer-id '(' expression-listₒₚₜ ')'
 part of the full-expression that performs the initialization. A
 *mem-initializer* where the *mem-initializer-id* denotes a virtual base
 class is ignored during execution of a constructor of any class that is
 not the most derived class.
+In a non-delegating constructor, if a given potentially constructed
+subobject is not designated by a *mem-initializer-id* (including the
 case where there is no *mem-initializer-list* because the constructor
+has no *ctor-initializer*), then
 - if the entity is a non-static data member that has a
+  *brace-or-equal-initializer* and either
+ - the constructor’s class is a union ([[class.union]]), and no other
+    variant member of that union is designated by a *mem-initializer-id*
+    or
+  - the constructor’s class is not a union, and, if the entity is a
+    member of an anonymous union, no other member of that union is
+    designated by a *mem-initializer-id*,
+  the entity is initialized as specified in  [[dcl.init]];
+- otherwise, if the entity is an anonymous union or a variant member (
+  [[class.union]]), no initialization is performed;
 - otherwise, the entity is default-initialized ([[dcl.init]]).
 An abstract class ([[class.abstract]]) is never a most derived class,
 thus its constructors never initialize virtual base classes, therefore
 the corresponding *mem-initializer*s may be omitted. An attempt to
 initialize more than one non-static data member of a union renders the
+program ill-formed. After the call to a constructor for class `X` for an
+object with automatic or dynamic storage duration has completed, if the
+constructor was not invoked as part of value-initialization and a member
+of `X` is neither initialized nor given a value during execution of the
+*compound-statement* of the body of the constructor, the member has an
+indeterminate value.
 ``` cpp
 struct A {
   A();
 };
 the `A(int)` constructor will simply initialize `i` to the value of
 `arg`, and the side effects in `i`’s *brace-or-equal-initializer* will
 not take place.
+In a non-delegating constructor, the destructor for each potentially
+constructed subobject of class type is potentially invoked (
+[[class.dtor]]). This provision ensures that destructors can be called
+for fully-constructed sub-objects in case an exception is thrown (
+[[except.ctor]]).
 In a non-delegating constructor, initialization proceeds in the
 following order:
 - First, and only for the constructor of the most derived class (
   [[intro.object]]), virtual base classes are initialized in the order
 one is declared *implicitly*. If the class definition declares a move
 constructor or move assignment operator, the implicitly declared copy
 constructor is defined as deleted; otherwise, it is defined as
 defaulted ([[dcl.fct.def]]). The latter case is deprecated if the class
 has a user-declared copy assignment operator or a user-declared
+destructor.
 The implicitly-declared copy constructor for a class `X` will have the
 form
 ``` cpp
 X::X(const X&)
 ```
+if each potentially constructed subobject of a class type `M` (or array
+thereof) has a copy constructor whose first parameter is of type `const`
+`M&` or `const` `volatile` `M&`.[^4] Otherwise, the implicitly-declared
+copy constructor will have the form
 ``` cpp
 X::X(X&)
 ```
 If the definition of a class `X` does not explicitly declare a move
 constructor, one will be implicitly declared as defaulted if and only if
 - `X` does not have a user-declared copy constructor,
 - `X` does not have a user-declared copy assignment operator,
+- `X` does not have a user-declared move assignment operator, and
+- `X` does not have a user-declared destructor.
 When the move constructor is not implicitly declared or explicitly
 supplied, expressions that otherwise would have invoked the move
 constructor may instead invoke a copy constructor.
 member of its class. A defaulted copy/move constructor for a class `X`
 is defined as deleted ([[dcl.fct.def.delete]]) if `X` has:
 - a variant member with a non-trivial corresponding constructor and `X`
   is a union-like class,
+- a potentially constructed subobject type `M` (or array thereof) that
   cannot be copied/moved because overload resolution ([[over.match]]),
   as applied to `M`’s corresponding constructor, results in an ambiguity
   or a function that is deleted or inaccessible from the defaulted
   constructor,
+- any potentially constructed subobject of a type with a destructor that
+ is deleted or inaccessible from the defaulted constructor, or,
 - for the copy constructor, a non-static data member of rvalue reference
+  type.
+A defaulted move constructor that is defined as deleted is ignored by
+overload resolution ([[over.match]], [[over.over]]). A deleted move
+constructor would otherwise interfere with initialization from an rvalue
+which can use the copy constructor instead.
 A copy/move constructor for class `X` is trivial if it is not
+user-provided, its parameter-type-list is equivalent to the
+parameter-type-list of an implicit declaration, and if
 - class `X` has no virtual functions ([[class.virtual]]) and no virtual
   base classes ([[class.mi]]), and
+- class `X` has no non-static data members of volatile-qualified type,
+  and
 - the constructor selected to copy/move each direct base class subobject
   is trivial, and
 - for each non-static data member of `X` that is of class type (or array
   thereof), the constructor selected to copy/move that member is
   trivial;
 otherwise the copy/move constructor is *non-trivial*.
 A copy/move constructor that is defaulted and not defined as deleted is
+*implicitly defined* if it is odr-used ([[basic.def.odr]]) or when it
 is explicitly defaulted after its first declaration. The copy/move
 constructor is implicitly defined even if the implementation elided its
 odr-use ([[basic.def.odr]], [[class.temporary]]). If the
 implicitly-defined constructor would satisfy the requirements of a
 `constexpr` constructor ([[dcl.constexpr]]), the implicitly-defined
 constructor is `constexpr`.
 Before the defaulted copy/move constructor for a class is implicitly
+defined, all non-user-provided copy/move constructors for its
+potentially constructed subobjects shall have been implicitly defined.
+An implicitly-declared copy/move constructor has an
 *exception-specification* ([[except.spec]]).
 The implicitly-defined copy/move constructor for a non-union class `X`
 performs a memberwise copy/move of its bases and members.
 *brace-or-equal-initializer*s of non-static data members are ignored.
 object representation ([[basic.types]]) of `X`.
 A user-declared *copy* assignment operator `X::operator=` is a
 non-static non-template member function of class `X` with exactly one
 parameter of type `X`, `X&`, `const` `X&`, `volatile` `X&` or `const`
+`volatile` `X&`.[^5] An overloaded assignment operator must be declared
 to have only one parameter; see  [[over.ass]]. More than one form of
 copy assignment operator may be declared for a class. If a class `X`
 only has a copy assignment operator with a parameter of type `X&`, an
 expression of type const `X` cannot be assigned to an object of type
 `X`.
 - each direct base class `B` of `X` has a copy assignment operator whose
   parameter is of type `const` `B&`, `const` `volatile` `B&` or `B`, and
 - for all the non-static data members of `X` that are of a class type
   `M` (or array thereof), each such class type has a copy assignment
   operator whose parameter is of type `const` `M&`, `const` `volatile`
+  `M&` or `M`.[^6]
 Otherwise, the implicitly-declared copy assignment operator will have
 the form
 ``` cpp
 assignment operator, one will be implicitly declared as defaulted if and
 only if
 - `X` does not have a user-declared copy constructor,
 - `X` does not have a user-declared move constructor,
+- `X` does not have a user-declared copy assignment operator, and
+- `X` does not have a user-declared destructor.
 The class definition
 ``` cpp
 struct S {
 - a variant member with a non-trivial corresponding assignment operator
   and `X` is a union-like class, or
 - a non-static data member of `const` non-class type (or array thereof),
   or
 - a non-static data member of reference type, or
+- a potentially constructed subobject of class type `M` (or array
+ thereof) that cannot be copied/moved because overload resolution (
+ [[over.match]]), as applied to `M`’s corresponding assignment
+ operator, results in an ambiguity or a function that is deleted or
+ inaccessible from the defaulted assignment operator.
+A defaulted move assignment operator that is defined as deleted is
+ignored by overload resolution ([[over.match]], [[over.over]]).
 Because a copy/move assignment operator is implicitly declared for a
 class if not declared by the user, a base class copy/move assignment
 operator is always hidden by the corresponding assignment operator of a
 derived class ([[over.ass]]). A *using-declaration* (
 declaration of the derived class operator; the operator introduced by
 the *using-declaration* is hidden by the implicitly-declared operator in
 the derived class.
 A copy/move assignment operator for class `X` is trivial if it is not
+user-provided, its parameter-type-list is equivalent to the
+parameter-type-list of an implicit declaration, and if
 - class `X` has no virtual functions ([[class.virtual]]) and no virtual
   base classes ([[class.mi]]), and
+- class `X` has no non-static data members of volatile-qualified type,
+  and
 - the assignment operator selected to copy/move each direct base class
   subobject is trivial, and
 - for each non-static data member of `X` that is of class type (or array
   thereof), the assignment operator selected to copy/move that member is
   trivial;
 otherwise the copy/move assignment operator is *non-trivial*.
+A copy/move assignment operator for a class `X` that is defaulted and
+not defined as deleted is *implicitly defined* when it is odr-used (
+[[basic.def.odr]]) (e.g., when it is selected by overload resolution to
+assign to an object of its class type) or when it is explicitly
+defaulted after its first declaration. The implicitly-defined copy/move
+assignment operator is `constexpr` if
+- `X` is a literal type, and
+- the assignment operator selected to copy/move each direct base class
+  subobject is a `constexpr` function, and
+- for each non-static data member of `X` that is of class type (or array
+  thereof), the assignment operator selected to copy/move that member is
+  a `constexpr` function.
 Before the defaulted copy/move assignment operator for a class is
 implicitly defined, all non-user-provided copy/move assignment operators
 for its direct base classes and its non-static data members shall have
 been implicitly defined. An implicitly-declared copy/move assignment
 Copying/moving one object into another using the copy/move constructor
 or the copy/move assignment operator does not change the layout or size
 of either object.
 When certain criteria are met, an implementation is allowed to omit the
+copy/move construction of a class object, even if the constructor
+selected for the copy/move operation and/or the destructor for the
+object have side effects. In such cases, the implementation treats the
+source and target of the omitted copy/move operation as simply two
+different ways of referring to the same object, and the destruction of
+that object occurs at the later of the times when the two objects would
+have been destroyed without the optimization.[^7] This elision of
+copy/move operations, called *copy elision*, is permitted in the
+following circumstances (which may be combined to eliminate multiple
+copies):
 - in a `return` statement in a function with a class return type, when
   the expression is the name of a non-volatile automatic object (other
   than a function or catch-clause parameter) with the same
   cv-unqualified type as the function return type, the copy/move
   same cv-unqualified type, the copy/move operation can be omitted by
   constructing the temporary object directly into the target of the
   omitted copy/move
 - when the of an exception handler (Clause  [[except]]) declares an
   object of the same type (except for cv-qualification) as the exception
+  object ([[except.throw]]), the copy operation can be omitted by
   treating the as an alias for the exception object if the meaning of
   the program will be unchanged except for the execution of constructors
+  and destructors for the object declared by the . There cannot be a
+  move from the exception object because it is always an lvalue.
 ``` cpp
 class Thing {
 public:
   Thing();
 viewed as directly initializing the global object `t2`, and that
 object’s destruction will occur at program exit. Adding a move
 constructor to `Thing` has the same effect, but it is the move
 construction from the temporary object to `t2` that is elided.
+When the criteria for elision of a copy/move operation are met, but not
+for an , and the object to be copied is designated by an lvalue, or when
+the *expression* in a `return` statement is a (possibly parenthesized)
+*id-expression* that names an object with automatic storage duration
+declared in the body or *parameter-declaration-clause* of the innermost
+enclosing function or *lambda-expression*, overload resolution to select
+the constructor for the copy is first performed as if the object were
+designated by an rvalue. If the first overload resolution fails or was
+not performed, or if the type of the first parameter of the selected
+constructor is not an rvalue reference to the object’s type (possibly
+cv-qualified), overload resolution is performed again, considering the
+object as an lvalue. This two-stage overload resolution must be
+performed regardless of whether copy elision will occur. It determines
+the constructor to be called if elision is not performed, and the
+selected constructor must be accessible even if the call is elided.
 ``` cpp
 class Thing {
 public:
   Thing();
 The *constructor characteristics* of a constructor or constructor
 template are
 - the template parameter list ([[temp.param]]), if any,
 - the *parameter-type-list* ([[dcl.fct]]),
 - absence or presence of `explicit` ([[class.conv.ctor]]), and
 - absence or presence of `constexpr` ([[dcl.constexpr]]).
 For each non-template constructor in the candidate set of inherited
 constructors other than a constructor having no parameters or a
 copy/move constructor having a single parameter, a constructor is
 implicitly declared with the same constructor characteristics unless
 there is a user-declared constructor with the same signature in the
+complete class where the *using-declaration* appears or the constructor
+would be a default, copy, or move constructor for that class. Similarly,
+for each constructor template in the candidate set of inherited
+constructors, a constructor template is implicitly declared with the
+same constructor characteristics unless there is an equivalent
+user-declared constructor template ([[temp.over.link]]) in the complete
+class where the *using-declaration* appears. Default arguments are not
+inherited. An *exception-specification* is implied as specified in
+[[except.spec]].
 A constructor so declared has the same access as the corresponding
 constructor in `X`. It is deleted if the corresponding constructor in
+`X` is deleted ([[dcl.fct.def]]). An inheriting constructor shall not
+be explicitly instantiated ([[temp.explicit]]) or explicitly
+specialized ([[temp.expl.spec]]).
 Default and copy/move constructors may be implicitly declared as
 specified in  [[class.ctor]] and  [[class.copy]].
 ``` cpp
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.types]: basic.md#basic.types
+[class]: class.md#class
 [class.abstract]: class.md#class.abstract
 [class.access]: class.md#class.access
 [class.base.init]: #class.base.init
 [class.cdtor]: #class.cdtor
 [class.conv]: #class.conv
 [class.copy]: #class.copy
 [class.ctor]: #class.ctor
 [class.dtor]: #class.dtor
 [class.expl.init]: #class.expl.init
 [class.free]: #class.free
+[class.friend]: class.md#class.friend
 [class.inhctor]: #class.inhctor
 [class.init]: #class.init
 [class.mem]: class.md#class.mem
 [class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
 [class.mi]: class.md#class.mi
+[class.qual]: basic.md#class.qual
 [class.temporary]: #class.temporary
 [class.union]: class.md#class.union
 [class.virtual]: class.md#class.virtual
 [conv]: conv.md#conv
 [conv.lval]: conv.md#conv.lval
 [dcl.array]: dcl.md#dcl.array
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
 [dcl.type.cv]: dcl.md#dcl.type.cv
 [diff.special]: compatibility.md#diff.special
 [except]: except.md#except
+[except.ctor]: except.md#except.ctor
 [except.spec]: except.md#except.spec
 [except.throw]: except.md#except.throw
 [expr]: expr.md#expr
 [expr.ass]: expr.md#expr.ass
 [expr.call]: expr.md#expr.call
 [over.best.ics]: over.md#over.best.ics
 [over.ics.ref]: over.md#over.ics.ref
 [over.load]: over.md#over.load
 [over.match]: over.md#over.match
 [over.match.best]: over.md#over.match.best
+[over.over]: over.md#over.over
 [special]: #special
 [stmt.dcl]: stmt.md#stmt.dcl
 [stmt.return]: stmt.md#stmt.return
+[temp.dep.type]: temp.md#temp.dep.type
+[temp.expl.spec]: temp.md#temp.expl.spec
+[temp.explicit]: temp.md#temp.explicit
 [temp.over.link]: temp.md#temp.over.link
 [temp.param]: temp.md#temp.param
 [temp.variadic]: temp.md#temp.variadic
+[^1]: The same rules apply to initialization of an `initializer_list`
+    object ([[dcl.init.list]]) with its underlying temporary array
+[^2]: These conversions are considered as standard conversions for the
     purposes of overload resolution ([[over.best.ics]],
     [[over.ics.ref]]) and therefore initialization ([[dcl.init]]) and
     explicit casts ([[expr.static.cast]]). A conversion to `void` does
     not invoke any conversion function ([[expr.static.cast]]). Even
     though never directly called to perform a conversion, such
     conversion functions can be declared and can potentially be reached
     through a call to a virtual conversion function in a base class.
+[^3]: A similar provision is not needed for the array version of
     `operator` `delete` because  [[expr.delete]] requires that in this
     situation, the static type of the object to be deleted be the same
     as its dynamic type.
 [^4]: This implies that the reference parameter of the
     implicitly-declared copy constructor cannot bind to a `volatile`
     lvalue; see  [[diff.special]].
+[^5]: Because a template assignment operator or an assignment operator
     taking an rvalue reference parameter is never a copy assignment
     operator, the presence of such an assignment operator does not
     suppress the implicit declaration of a copy assignment operator.
     Such assignment operators participate in overload resolution with
     other assignment operators, including copy assignment operators,
     and, if selected, will be used to assign an object.
+[^6]: This implies that the reference parameter of the
     implicitly-declared copy assignment operator cannot bind to a
     `volatile` lvalue; see  [[diff.special]].
+[^7]: Because only one object is destroyed instead of two, and one
     copy/move constructor is not executed, there is still one object
     destroyed for each one constructed.

Diff to HTML by rtfpessoa