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

Files changed (1) hide show

tmp/tmpc_mxg71i/{from.md → to.md} +89 -193

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

@@ -8,44 +8,49 @@ 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 {
@@ -66,58 +71,61 @@ 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 {
@@ -149,142 +157,30 @@ Weird g() {
 }
 ```
 — *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.

 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.[^14] 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 object with automatic
+ storage duration (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 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 object with automatic storage duration (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 can be omitted by constructing the object directly
+ into the exception object
+- in a coroutine [[dcl.fct.def.coroutine]], a copy of a coroutine
+ parameter can be omitted and references to that copy replaced with
+ references to the corresponding parameter if the meaning of the
+ program will be unchanged except for the execution of a constructor
+ and destructor for the parameter copy object
+- when the *exception-declaration* of an exception handler
+ [[except.pre]] 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 not permitted 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 be performed if the same expression is
+evaluated in another context. — *end note*]
 [*Example 1*:
 ``` cpp
 class Thing {
   void *p;
   constexpr A(): p(this) {}
 };
 constexpr A g() {
+  A loc;
+  return loc;
 }
 constexpr A a;          // well-formed, a.p points to a
+constexpr A b = g();    // error: b.p would be dangling[expr.const]
+void h() {
   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 object
+`t` with automatic storage duration 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 object with automatic
+storage duration to `t2` that is elided.
 — *end example*]
+An *implicitly movable entity* is a variable of automatic storage
+duration that is either a non-volatile object or an rvalue reference to
+a non-volatile object type. In the following copy-initialization
+contexts, a move operation might be used instead of a copy operation:
+- If the *expression* in a `return` [[stmt.return]] or `co_return`
+ [[stmt.return.coroutine]] statement is a (possibly parenthesized)
+ *id-expression* that names an implicitly movable entity 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 a (possibly
+ parenthesized) *id-expression* that names an implicitly movable entity
+  whose scope does not extend beyond the *compound-statement* of the
+  innermost *try-block* or *function-try-block* (if any) whose
+  *compound-statement* or *ctor-initializer* encloses the
+  *throw-expression*,
+overload resolution to select the constructor for the copy or the
+`return_value` overload to call is first performed as if the expression
+or operand were an rvalue. If the first overload resolution fails or was
+not performed, overload resolution is performed again, considering the
+expression or operand as an lvalue.
 [*Note 3*: This two-stage overload resolution must be performed
 regardless of whether copy elision will occur. It determines the
+constructor or the `return_value` overload to be called if elision is
+not performed, and the selected constructor or `return_value` overload
+must be accessible even if the call is elided. — *end note*]
 [*Example 2*:
 ``` cpp
 class Thing {
 }
 ```
 — *end example*]
+[*Example 3*:
+``` cpp
+template<class T> void g(const T&);
+template<class T> void f() {
+  T x;
+  try {
+ T y;
+ try { g(x); }
+ catch (...) {
+      if (/*...*/)
+        throw x;        // does not move
+      throw y;          // moves
+    }
+    g(y);
+  } catch(...) {
+    g(x);
+    g(y);               // error: y is not in scope
+  }
+}
+```
+— *end example*]

Diff to HTML by rtfpessoa