• 1Explanation
• 2Prvalue semantics ("guaranteed copy elision")
• 3Notes
• 4Example
• 5Defect reports
• 6See also

• When a class objecttarget is copy-initialized with a temporary class objectobj that has not been bound to a reference, the copy-initialization can be omitted by constructingobj directly intotarget. This variant of copy elision is known asunnamed return value optimization (URVO). Since C++17, URVO is mandatory and no longer considered a form of copy elision; see below.

• In athrow expression, when the operand is the name of a non-volatile objectobj with automatic storage duration (other than a function parameter or a handler parameter) that belongs to ascope that does not contain the innermost enclosingtry block (if exists), the copy-initialization of the exception object can be omitted by constructingobj directly into the exception object.
• In ahandler, the copy-initialization of the handler argument can be omitted by treating the handler parameter 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 handler argument.

• Incoroutines, a copy of a coroutine parameter can be omitted. In this case, references to that copy are 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.

The destruction occurs at the later of the times when the two objects would have been destroyed without the optimization.

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.

Prvalue semantics ("guaranteed copy elision")

Since C++17, a prvalue is not materialized until needed, and then it is constructed directly into the storage of its final destination. This sometimes means that even when the language syntax visually suggests a copy/move (e.g.copy initialization), no copy/move is performed — which means the type need not have an accessible copy/move constructor at all. Examples include:

• Initializing the returned object in areturn statement, when the operand is aprvalue of the same class type (ignoringcv-qualification) as the function return type:

T f(){return U();// constructs a temporary of type U,// then initializes the returned T from the temporary}T g(){return T();// constructs the returned T directly; no move}

The destructor of the type returned must be accessible at the point of the return statement and non-deleted, even though no T object is destroyed.

• In the initialization of an object, when the initializer expression is aprvalue of the same class type (ignoringcv-qualification) as the variable type:

T x= T(T(f()));// x is initialized by the result of f() directly; no move

This can only apply when the object being initialized is known not to be a potentially-overlapping subobject:

struct C{/* ... */};C f(); struct D;D g(); struct D: C{    D(): C(f()){}// no elision when initializing a base class subobject    D(int): D(g()){}// no elision because the D object being initialized might// be a base-class subobject of some other class};

Note: This rule does not specify an optimization, and the Standard does not formally describe it as "copy elision" (because nothing is being elided). Instead, the C++17 core language specification ofprvalues andtemporaries is fundamentally different from that of earlier C++ revisions: there is no longer a temporary to copy/move from. Another way to describe C++17 mechanics is "unmaterialized value passing" or "deferred temporary materialization": prvalues are returned and used without ever materializing a temporary.

In areturn statement or athrow expression, if the compiler cannot perform copy elision but the conditions for copy elision are met, or would be met except that the source is a function parameter,the compiler will attempt to use the move constructor even if the source operand is designated by an lvalue(until C++23)the source operand will be treated as an rvalue(since C++23); seereturn statement for details.

Inconstant expression andconstant initialization, copy elision is never performed.

struct A{void* p;constexpr A(): p(this){}    A(const A&);// Disable trivial copyability}; constexpr A a;// OK: a.p points to a constexpr A f(){    A x;return x;}constexpr A b= f();// error: b.p would be dangling and point to the x inside f constexpr A c= A();// (until C++17) error: c.p would be dangling and point to a temporary// (since C++17) OK: c.p points to c; no temporary is involved