Copy elision

• En una throw expresión , cuando el operando es el nombre de un objeto no volátil obj con duración de almacenamiento automático (que no sea un parámetro de función o un parámetro de manejador) que pertenece a un ámbito que no contiene el try bloque envolvente más interno (si existe), la inicialización por copia del objeto de excepción puede omitirse construyendo obj directamente en el objeto de excepción.
• En un manejador , la inicialización por copia del argumento del manejador puede omitirse tratando el parámetro del manejador como un alias del objeto de excepción si el significado del programa permanece inalterado excepto por la ejecución de constructores y destructores para el argumento del manejador.

• En corrutinas , puede omitirse una copia de un parámetro de corrutina. En este caso, las referencias a esa copia se reemplazan con referencias al parámetro correspondiente si el significado del programa permanece inalterado excepto por la ejecución de un constructor y destructor para el objeto copia del parámetro.

Si el primer parámetro del constructor seleccionado es una referencia a valor del tipo del objeto, la destrucción de ese objeto ocurre cuando el objetivo habría sido destruido. De lo contrario, la destrucción ocurre en el momento posterior entre los dos momentos en que los dos objetos habrían sido destruidos sin la optimización.

Semántica de prvalue ("eliminación de copia garantizada")

Desde C++17, un prvalue no se materializa hasta que se necesita, y luego se construye directamente en el almacenamiento de su destino final. Esto significa que incluso cuando la sintaxis del lenguaje sugiere visualmente una copia/movimiento (por ejemplo, inicialización por copia ), no se realiza ninguna copia/movimiento, lo que significa que el tipo no necesita tener un constructor de copia/movimiento accesible en absoluto. Los ejemplos incluyen:

• Inicializar el objeto devuelto en una sentencia return , cuando el operando es un prvalue del mismo tipo de clase (ignorando calificación cv ) que el tipo de retorno de la función:

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
}

El destructor del tipo devuelto debe ser accesible en el punto de la sentencia return y no eliminado, incluso cuando no se destruya ningún objeto T.

• En la inicialización de un objeto, cuando la expresión de inicialización es un prvalue del mismo tipo de clase (ignorando calificación cv ) que el tipo de la variable:

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

Esto solo puede aplicarse cuando se sabe que el objeto que se está inicializando no es un subobjeto potencialmente superpuesto:

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
};

Nota: Esta regla no especifica una optimización, y el Estándar no la describe formalmente como "eliminación de copia" (porque no se está eliminando nada). En cambio, la especificación del lenguaje central de C++17 de prvalues y temporales es fundamentalmente diferente de la de revisiones anteriores de C++: ya no hay un temporal del cual copiar/mover. Otra forma de describir la mecánica de C++17 es "paso de valor no materializado" o "materialización temporal diferida": los prvalues se devuelven y se utilizan sin materializar nunca un temporal.

En una sentencia return o una expresión throw , si el compilador no puede realizar la copy elision pero se cumplen las condiciones para la copy elision, o se cumplirían excepto que la fuente es un parámetro de función, el compilador intentará usar el move constructor incluso si el operando fuente está designado por un lvalue (until C++23) el operando fuente será tratado como un rvalue (since C++23) ; consulte return statement para más detalles.

En constant expression y constant initialization , la copy elision nunca se realiza.

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