[class.copy] - C++17 → C++20

Files changed (1) hide show

tmp/tmpync44ph5/{from.md → to.md} +0 -772

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

@@ -1,772 +0,0 @@
-## Copying and moving class objects <a id="class.copy">[[class.copy]]</a>
-A class object can be copied or moved in two ways: by initialization (
-[[class.ctor]], [[dcl.init]]), including for function argument passing (
-[[expr.call]]) and for function value return ([[stmt.return]]); and by
-assignment ([[expr.ass]]). Conceptually, these two operations are
-implemented by a copy/move constructor ([[class.ctor]]) and copy/move
-assignment operator ([[over.ass]]).
-A program is ill-formed if the copy/move constructor or the copy/move
-assignment operator for an object is implicitly odr-used and the special
-member function is not accessible (Clause  [[class.access]]).
-[*Note 1*: 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. — *end note*]
-### Copy/move constructors <a id="class.copy.ctor">[[class.copy.ctor]]</a>
-A non-template constructor for class `X` is a copy constructor if its
-first parameter is of type `X&`, `const X&`, `volatile X&` or
-`const volatile X&`, and either there are no other parameters or else
-all other parameters have default arguments ([[dcl.fct.default]]).
-[*Example 1*:
-`X::X(const X&)`
-and `X::X(X&,int=1)` are copy constructors.
-``` cpp
-struct X {
-  X(int);
-  X(const X&, int = 1);
-};
-X a(1);             // calls X(int);
-X b(a, 0);          // calls X(const X&, int);
-X c = b;            // calls X(const X&, int);
-```
-— *end example*]
-A non-template constructor for class `X` is a move constructor if its
-first parameter is of type `X&&`, `const X&&`, `volatile X&&`, or
-`const volatile X&&`, and either there are no other parameters or else
-all other parameters have default arguments ([[dcl.fct.default]]).
-[*Example 2*:
-`Y::Y(Y&&)` is a move constructor.
-``` cpp
-struct Y {
-  Y(const Y&);
-  Y(Y&&);
-};
-extern Y f(int);
-Y d(f(1));          // calls Y(Y&&)
-Y e = d;            // calls Y(const Y&)
-```
-— *end example*]
-[*Note 1*:
-All forms of copy/move constructor may be declared for a class.
-[*Example 3*:
-``` cpp
-struct X {
-  X(const X&);
-  X(X&);            // OK
-  X(X&&);
-  X(const X&&);     // OK, but possibly not sensible
-};
-```
-— *end example*]
-— *end note*]
-[*Note 2*:
-If a class `X` only has a copy constructor with a parameter of type
-`X&`, an initializer of type `const` `X` or `volatile` `X` cannot
-initialize an object of type (possibly cv-qualified) `X`.
-[*Example 4*:
-``` cpp
-struct X {
-  X();              // default constructor
-  X(X&);            // copy constructor with a non-const parameter
-};
-const X cx;
-X x = cx;           // error: X::X(X&) cannot copy cx into x
-```
-— *end example*]
-— *end note*]
-A declaration of a constructor for a class `X` is ill-formed if its
-first parameter is of type (optionally cv-qualified) `X` and either
-there are no other parameters or else all other parameters have default
-arguments. A member function template is never instantiated to produce
-such a constructor signature.
-[*Example 5*:
-``` cpp
-struct S {
-  template<typename T> S(T);
-  S();
-};
-S g;
-void h() {
-  S a(g);           // does not instantiate the member template to produce S::S<S>(S);
-                    // uses the implicitly declared copy constructor
-}
-```
-— *end example*]
-If the class definition does not explicitly declare a copy constructor,
-a non-explicit 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, a non-explicit 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.
-[*Note 3*: 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. — *end note*]
-The implicitly-declared move constructor for class `X` will have the
-form
-``` cpp
-X::X(X&&)
-```
-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 potentially constructed subobject type `M` (or array thereof) that
-  cannot be copied/moved because overload resolution ([[over.match]]),
-  as applied to find `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]]).
-[*Note 4*: A deleted move constructor would otherwise interfere with
-initialization from an rvalue which can use the copy constructor
-instead. — *end note*]
-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]]) or when it
-is explicitly defaulted after its first declaration.
-[*Note 5*: The copy/move constructor is implicitly defined even if the
-implementation elided its odr-use ([[basic.def.odr]],
-[[class.temporary]]). — *end note*]
-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.
-[*Note 6*: An implicitly-declared copy/move constructor has an implied
-exception specification ([[except.spec]]). — *end note*]
-The implicitly-defined copy/move constructor for a non-union class `X`
-performs a memberwise copy/move of its bases and members.
-[*Note 7*: Default member initializers of non-static data members are
-ignored. See also the example in  [[class.base.init]]. — *end note*]
-The order of initialization is the same as the order of initialization
-of bases and members in a user-defined constructor (see
-[[class.base.init]]). Let `x` be either the parameter of the constructor
-or, for the move constructor, an xvalue referring to the parameter. Each
-base or non-static data member is copied/moved in the manner appropriate
-to its type:
-- if the member is an array, each element is direct-initialized with the
-  corresponding subobject of `x`;
-- if a member `m` has rvalue reference type `T&&`, it is
-  direct-initialized with `static_cast<T&&>(x.m)`;
-- otherwise, the base or member is direct-initialized with the
-  corresponding base or member of `x`.
-Virtual base class subobjects shall be initialized only once by the
-implicitly-defined copy/move constructor (see  [[class.base.init]]).
-The implicitly-defined copy/move constructor for a union `X` copies the
-object representation ([[basic.types]]) of `X`.
-### Copy/move assignment operator <a id="class.copy.assign">[[class.copy.assign]]</a>
-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]
-[*Note 1*: An overloaded assignment operator must be declared to have
-only one parameter; see  [[over.ass]]. — *end note*]
-[*Note 2*: More than one form of copy assignment operator may be
-declared for a class. — *end note*]
-[*Note 3*:
-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`.
-[*Example 1*:
-``` cpp
-struct X {
-  X();
-  X& operator=(X&);
-};
-const X cx;
-X x;
-void f() {
-  x = cx;           // error: X::operator=(X&) cannot assign cx into x
-}
-```
-— *end example*]
-— *end note*]
-If the class definition does not explicitly declare a copy assignment
-operator, one is declared *implicitly*. If the class definition declares
-a move constructor or move assignment operator, the implicitly declared
-copy assignment operator 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 constructor or a user-declared
-destructor. The implicitly-declared copy assignment operator for a class
-`X` will have the form
-``` cpp
-X& X::operator=(const X&)
-```
-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`.[^6]
-Otherwise, the implicitly-declared copy assignment operator will have
-the form
-``` cpp
-X& X::operator=(X&)
-```
-A user-declared move assignment operator `X::operator=` is a non-static
-non-template member function of class `X` with exactly one parameter of
-type `X&&`, `const X&&`, `volatile X&&`, or `const volatile X&&`.
-[*Note 4*: An overloaded assignment operator must be declared to have
-only one parameter; see  [[over.ass]]. — *end note*]
-[*Note 5*: More than one form of move assignment operator may be
-declared for a class. — *end note*]
-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, and
-- `X` does not have a user-declared destructor.
-[*Example 2*:
-The class definition
-``` cpp
-struct S {
-  int a;
-  S& operator=(const S&) = default;
-};
-```
-will not have a default move assignment operator implicitly declared
-because the copy assignment operator has been user-declared. The move
-assignment operator may be explicitly defaulted.
-``` cpp
-struct S {
-  int a;
-  S& operator=(const S&) = default;
-  S& operator=(S&&) = default;
-};
-```
-— *end example*]
-The implicitly-declared move assignment operator for a class `X` will
-have the form
-``` cpp
-X& X::operator=(X&&);
-```
-The implicitly-declared copy/move assignment operator for class `X` has
-the return type `X&`; it returns the object for which the assignment
-operator is invoked, that is, the object assigned to. An
-implicitly-declared copy/move assignment operator is an `inline`
-`public` member of its class.
-A defaulted copy/move assignment operator for class `X` is defined as
-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 direct non-static data member of class type `M` (or array thereof)
-  or a direct base class `M` that cannot be copied/moved because
-  overload resolution ([[over.match]]), as applied to find `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* (
-[[namespace.udecl]]) that brings in from a base class an assignment
-operator with a parameter type that could be that of a copy/move
-assignment operator for the derived class is not considered an explicit
-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 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.
-[*Note 6*: An implicitly-declared copy/move assignment operator has an
-implied exception specification ([[except.spec]]). — *end note*]
-The implicitly-defined copy/move assignment operator for a non-union
-class `X` performs memberwise copy/move assignment of its subobjects.
-The direct base classes of `X` are assigned first, in the order of their
-declaration in the *base-specifier-list*, and then the immediate
-non-static data members of `X` are assigned, in the order in which they
-were declared in the class definition. Let `x` be either the parameter
-of the function or, for the move operator, an xvalue referring to the
-parameter. Each subobject is assigned in the manner appropriate to its
-type:
-- if the subobject is of class type, as if by a call to `operator=` with
-  the subobject as the object expression and the corresponding subobject
-  of `x` as a single function argument (as if by explicit qualification;
-  that is, ignoring any possible virtual overriding functions in more
-  derived classes);
-- if the subobject is an array, each element is assigned, in the manner
-  appropriate to the element type;
-- if the subobject is of scalar type, the built-in assignment operator
-  is used.
-It is unspecified whether subobjects representing virtual base classes
-are assigned more than once by the implicitly-defined copy/move
-assignment operator.
-[*Example 3*:
-``` cpp
-struct V { };
-struct A : virtual V { };
-struct B : virtual V { };
-struct C : B, A { };
-```
-It is unspecified whether the virtual base class subobject `V` is
-assigned twice by the implicitly-defined copy/move assignment operator
-for `C`.
-— *end example*]
-The implicitly-defined copy assignment operator for a union `X` copies
-the object representation ([[basic.types]]) of `X`.
-### Copy/move elision <a id="class.copy.elision">[[class.copy.elision]]</a>
-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. If the first parameter
-of the selected constructor is an rvalue reference to the object’s type,
-the destruction of that object occurs when the target would have been
-destroyed; otherwise, the destruction 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 parameter or a variable introduced by the
-  *exception-declaration* of a *handler* ([[except.handle]])) with the
-  same type (ignoring cv-qualification) as the function return type, the
-  copy/move operation can be omitted by constructing the automatic
-  object directly into the function call’s return object
-- in a *throw-expression* ([[expr.throw]]), when the operand is the
-  name of a non-volatile automatic object (other than a function or
-  catch-clause parameter) whose scope does not extend beyond the end of
-  the innermost enclosing *try-block* (if there is one), the copy/move
-  operation from the operand to the exception object ([[except.throw]])
-  can be omitted by constructing the automatic object directly into the
-  exception object
-- when the *exception-declaration* 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 *exception-declaration*
-  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 *exception-declaration*.
-  \[*Note 1*: There cannot be a move from the exception object because
-  it is always an lvalue. — *end note*]
-Copy elision is required where an expression is evaluated in a context
-requiring a constant expression ([[expr.const]]) and in constant
-initialization ([[basic.start.static]]).
-[*Note 2*: Copy elision might not be performed if the same expression
-is evaluated in another context. — *end note*]
-[*Example 1*:
-``` cpp
-class Thing {
-public:
-  Thing();
-  ~Thing();
-  Thing(const Thing&);
-};
-Thing f() {
-  Thing t;
-  return t;
-}
-Thing t2 = f();
-struct A {
-  void *p;
-  constexpr A(): p(this) {}
-};
-constexpr A g() {
-  A a;
-  return a;
-}
-constexpr A a;          // well-formed, a.p points to a
-constexpr A b = g();    // well-formed, b.p points to b
-void g() {
-  A c = g();            // well-formed, c.p may point to c or to an ephemeral temporary
-}
-```
-Here the criteria for elision can eliminate the copying of the local
-automatic object `t` into the result object for the function call `f()`,
-which is the global object `t2`. Effectively, the construction of the
-local object `t` can be 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 local automatic object to `t2` that is
-elided.
-— *end example*]
-In the following copy-initialization contexts, a move operation might be
-used instead of a copy operation:
-- If the *expression* in a `return` statement ([[stmt.return]]) 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*, or
-- if the operand of a *throw-expression* ([[expr.throw]]) is the name
-  of a non-volatile automatic object (other than a function or
-  catch-clause parameter) whose scope does not extend beyond the end of
-  the innermost enclosing *try-block* (if there is one),
-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.
-[*Note 3*: 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. — *end note*]
-[*Example 2*:
-``` cpp
-class Thing {
-public:
-  Thing();
-  ~Thing();
-  Thing(Thing&&);
-private:
-  Thing(const Thing&);
-};
-Thing f(bool b) {
-  Thing t;
-  if (b)
-    throw t;            // OK: Thing(Thing&&) used (or elided) to throw t
-  return t;             // OK: Thing(Thing&&) used (or elided) to return t
-}
-Thing t2 = f(false);    // OK: no extra copy/move performed, t2 constructed by call to f
-struct Weird {
-  Weird();
-  Weird(Weird&);
-};
-Weird g() {
-  Weird w;
-  return w;             // OK: first overload resolution fails, second overload resolution selects Weird(Weird&)
-}
-```
-— *end example*]
-<!-- Link reference definitions -->
-[basic.def.odr]: basic.md#basic.def.odr
-[basic.life]: basic.md#basic.life
-[basic.lookup]: basic.md#basic.lookup
-[basic.lval]: basic.md#basic.lval
-[basic.start.dynamic]: basic.md#basic.start.dynamic
-[basic.start.static]: basic.md#basic.start.static
-[basic.start.term]: basic.md#basic.start.term
-[basic.stc.auto]: basic.md#basic.stc.auto
-[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.conv.ctor]: #class.conv.ctor
-[class.conv.fct]: #class.conv.fct
-[class.copy]: #class.copy
-[class.copy.assign]: #class.copy.assign
-[class.copy.ctor]: #class.copy.ctor
-[class.copy.elision]: #class.copy.elision
-[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.init]: #class.inhctor.init
-[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.union.anon]: class.md#class.union.anon
-[class.virtual]: class.md#class.virtual
-[conv]: conv.md#conv
-[conv.array]: conv.md#conv.array
-[conv.rval]: conv.md#conv.rval
-[dcl.array]: dcl.md#dcl.array
-[dcl.constexpr]: dcl.md#dcl.constexpr
-[dcl.fct]: dcl.md#dcl.fct
-[dcl.fct.def]: dcl.md#dcl.fct.def
-[dcl.fct.def.delete]: dcl.md#dcl.fct.def.delete
-[dcl.fct.default]: dcl.md#dcl.fct.default
-[dcl.fct.spec]: dcl.md#dcl.fct.spec
-[dcl.init]: dcl.md#dcl.init
-[dcl.init.aggr]: dcl.md#dcl.init.aggr
-[dcl.init.list]: dcl.md#dcl.init.list
-[dcl.init.ref]: dcl.md#dcl.init.ref
-[dcl.spec.auto]: dcl.md#dcl.spec.auto
-[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.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
-[expr.cast]: expr.md#expr.cast
-[expr.const]: expr.md#expr.const
-[expr.const.cast]: expr.md#expr.const.cast
-[expr.delete]: expr.md#expr.delete
-[expr.dynamic.cast]: expr.md#expr.dynamic.cast
-[expr.mptr.oper]: expr.md#expr.mptr.oper
-[expr.new]: expr.md#expr.new
-[expr.prim]: expr.md#expr.prim
-[expr.prim.lambda.capture]: expr.md#expr.prim.lambda.capture
-[expr.pseudo]: expr.md#expr.pseudo
-[expr.ref]: expr.md#expr.ref
-[expr.sizeof]: expr.md#expr.sizeof
-[expr.static.cast]: expr.md#expr.static.cast
-[expr.sub]: expr.md#expr.sub
-[expr.throw]: expr.md#expr.throw
-[expr.type.conv]: expr.md#expr.type.conv
-[expr.typeid]: expr.md#expr.typeid
-[expr.unary.op]: expr.md#expr.unary.op
-[intro.execution]: intro.md#intro.execution
-[intro.object]: intro.md#intro.object
-[namespace.udecl]: dcl.md#namespace.udecl
-[over.ass]: over.md#over.ass
-[over.best.ics]: over.md#over.best.ics
-[over.ics.ref]: over.md#over.ics.ref
-[over.match]: over.md#over.match
-[over.match.best]: over.md#over.match.best
-[over.match.copy]: over.md#over.match.copy
-[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.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