Compiler Support for Copy Elision

Copy elision, including Return Value Optimization (RVO), is a compiler optimization technique that eliminates unnecessary copies of objects. However, the degree to which copy elision is applied can vary depending on the compiler and the optimization settings used.

In C++17 and later, certain forms of copy elision are guaranteed by the language standard. Specifically, the standard requires that copy elision is performed in the following cases:

1. When an object is returned directly from a function, and the return type matches the type of the returned object.
2. When an exception is thrown, and the exception object is copied from a temporary object.
3. When a temporary object is bound to a reference or used to initialize an object, and the lifetime of the temporary object would extend to the lifetime of the reference or object.

In these cases, the compiler must perform copy elision, and the copy or move constructors are not called.

Here's an example where copy elision is guaranteed:

1MyClass createObject() {
2  // Guaranteed copy elision
3  return MyClass{};
4}
5
6int main() {
7  // No copy or move constructor called
8  MyClass obj = createObject();
9}

However, in other cases, copy elision is still optional and depends on the compiler and optimization settings. For example:

1MyClass createObject(bool flag) {
2  MyClass obj1, obj2;
3
4  // Optional copy elision
5  return flag ? obj1 : obj2;
6}

In this case, the compiler may or may not perform copy elision when returning obj1 or obj2, depending on its optimization capabilities and the settings used.

It's important to note that even if copy elision is not performed, the compiler is still allowed to optimize out the copy or move operations if they have no observable side effects.

To ensure maximum performance, it's generally recommended to:

1. Enable compiler optimizations when building your code in release mode.
2. Write code that facilitates copy elision, such as returning objects directly from functions.
3. Implement move semantics for your classes to enable efficient transfer of resources when copy elision is not possible.

By relying on guaranteed copy elision and enabling compiler optimizations, you can write efficient code that minimizes unnecessary copies and moves.