Difference between revisions of "cpp/language/copy elision"

Revision as of 01:53, 23 October 2018

Omits copy and move(since C++11) constructors, resulting in zero-copy pass-by-value semantics.

Under the following circumstances, the compilers are required to omit the copy and move construction of class objects, even if the copy/move constructor and the destructor have observable side-effects. The objects are constructed directly into the storage where they would otherwise be copied/moved to. The copy/move constructors need not be present or accessible, as the language rules ensure that no copy/move operation takes place, even conceptually:

In a return statement, when the operand is a prvalue of the same class type (ignoring cv-qualification) as the function return type:

T f() {
    return T();
}
 
f(); // only one call to default constructor of T

In the initialization of a variable, when the initializer expression is a prvalue of the same class type (ignoring cv-qualification) as the variable type:

T x = T(T(f())); // only one call to default constructor of T, to initialize x

Note: the rule above does not specify an optimization: C++17 core language specification of prvalues and temporaries is fundamentally different from that of the earlier C++ revisions: there is no longer a temporary to copy/move from. Another way to describe C++17 mechanics is "unmaterialized value passing": prvalues are returned and used without ever materializing a temporary.

(since C++17)

Under the following circumstances, the compilers are permitted, but not required to omit the copy and move(since C++11) construction of class objects even if the copy/move(since C++11) constructor and the destructor have observable side-effects. The objects are constructed directly into the storage where they would otherwise be copied/moved to. This is an optimization: even when it takes place and the copy/move(since C++11) constructor is not called, it still must be present and accessible (as if no optimization happened at all), otherwise the program is ill-formed:

In a return statement, when the operand is the name of a non-volatile object with automatic storage duration, which isn't a function parameter or a catch clause parameter, and which is of the same class type (ignoring cv-qualification) as the function return type. This variant of copy elision is known as NRVO, "named return value optimization".

In the initialization of an object, when the source object is a nameless temporary and is of the same class type (ignoring cv-qualification) as the target object. When the nameless temporary is the operand of a return statement, this variant of copy elision is known as RVO, "return value optimization".	(until C++17)
This optimization is mandatory; see above.	(since C++17)

In a throw-expression, when the operand is the name of a non-volatile object with automatic storage duration, which isn't a function parameter or a catch clause parameter, and whose scope does not extend past the innermost try-block (if there is a try-block).
In a catch clause, when the argument is of the same type (ignoring cv-qualification) as the exception object thrown, the copy of the exception object is omitted and the body of the catch clause accesses the exception object directly, as if caught by reference (there cannot be a move from the exception object because it is always an lvalue). This is disabled if such copy elision would change the observable behavior of the program for any reason other than skipping the copy constructor and the destructor of the catch clause argument (for example, if the catch clause argument is modified, and the exception object is rethrown with throw).

(since C++11)

When copy elision occurs, the implementation treats the source and target of the omitted copy/move(since C++11) 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 (except that, if the parameter of the selected constructor is an rvalue reference to object type, the destruction occurs when the target would have been destroyed)(since C++17).

Multiple copy elisions may be chained to eliminate multiple copies.

In constant expression and constant initialization, all copy elision is guaranteed (note: this is specified by post-C++14 defect report CWG 2022, which may be reversed pending decision on CWG 2278):

struct A {
    void *p;
    constexpr A(): p(this) {}
};
 
constexpr A g() {
    A a;
    return a;
}
 
constexpr A a;       // a.p points to a
constexpr A b = g(); // b.p points to b (NRVO guaranteed)
 
void g() {
    A c = g();       // c.p may point to c or to an ephemeral temporary
}

(since C++14)

Notes

Copy elision is the only allowed form of optimization(until C++14)one of the two allowed forms of optimization, alongside allocation elision and extension,(since C++14) that can change the observable side-effects. Because some compilers do not perform copy elision in every situation where it is allowed (e.g., in debug mode), programs that rely on the side-effects of copy/move constructors and destructors are not portable.

In a return statement or a throw-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 object is designated by an lvalue; see return statement for details.

(since C++11)

Example

Run this code

#include <iostream>
#include <vector>
 
struct Noisy {
    Noisy() { std::cout << "constructed\n"; }
    Noisy(const Noisy&) { std::cout << "copy-constructed\n"; }
    Noisy(Noisy&&) { std::cout << "move-constructed\n"; }
    ~Noisy() { std::cout << "destructed\n"; }
};
 
std::vector<Noisy> f() {
    std::vector<Noisy> v = std::vector<Noisy>(3); // copy elision when initializing v
                                                  // from a temporary (until C++17)
                                                  // from a prvalue (since C++17)
    return v; // NRVO from v to the result object (not guaranteed, even in C++17)
}             // if optimization is disabled, the move constructor is called
 
void g(std::vector<Noisy> arg) {
    std::cout << "arg.size() = " << arg.size() << '\n';
}
 
int main() {
    std::vector<Noisy> v = f(); // copy elision in initialization of v
                                // from the temporary returned by f() (until C++17)
                                // from the prvalue f() (since C++17)
    g(f());                     // copy elision in initialization of the parameter of g()
                                // from the temporary returned by f() (until C++17)
                                // from the prvalue f() (since C++17)
}

Possible output:

constructed
constructed
constructed
constructed
constructed
constructed
arg.size() = 3
destructed
destructed
destructed
destructed
destructed
destructed

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
CWG 2022	C++14	copy elision was optional in constant expressions	copy elision mandatory

@@ Line 6: / Line 6: @@
 {{rrev|since=c++17|
 Under the following circumstances, the compilers are required to omit the copy and move construction of class objects, even if the copy/move constructor and the destructor have observable side-effects. The objects are constructed directly into the storage where they would otherwise be copied/moved to. The copy/move constructors need not be present or accessible, as the language rules ensure that no copy/move operation takes place, even conceptually:
-* In the initialization of a variable, when the initializer expression is a {{rlp|value category|prvalue}} of the same class type (ignoring {{rlp|cv|cv-qualification}}) as the variable type:
-{{source|1=
-T x = T(T(T())); // only one call to default constructor of T, to initialize x
-}}
 * In a {{rlp|return|return statement}}, when the operand is a {{rlp|value category|prvalue}} of the same class type (ignoring {{rlp|cv|cv-qualification}}) as the function return type:
 {{source|1=
@@ Line 17: / Line 13: @@
 f(); // only one call to default constructor of T
+}}
+* In the initialization of a variable, when the initializer expression is a {{rlp|value category|prvalue}} of the same class type (ignoring {{rlp|cv|cv-qualification}}) as the variable type:
+{{source|1=
+T x = T(T(f())); // only one call to default constructor of T, to initialize x
 }}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

Initializer
Default initialization
Value initialization
Direct initialization
Copy-initialization
List initialization (C++11)
Aggregate initialization
Reference initialization
Copy elision
Static initialization
Zero initialization
Constant initialization
Dynamic non-local initialization
Ordered dynamic initialization
Unordered dynamic initialization
Class member initialization
Member initializer list
Default member initializer (C++11)

cppreference.com

Namespaces

Variants

Views

Actions

Difference between revisions of "cpp/language/copy elision"

Revision as of 01:53, 23 October 2018

Contents

Explanation

Notes

Example

Defect reports

See also

Navigation

Toolbox