Copy elision

• В throw выражении , когда операндом является имя не-volatile объекта obj с автоматической продолжительностью хранения (кроме параметра функции или параметра обработчика), который принадлежит области видимости , не содержащей самый внутренний охватывающий try блок (если существует), копирующая инициализация объекта исключения может быть опущена путем непосредственного конструирования obj в объект исключения.
• В обработчике , копирующая инициализация аргумента обработчика может быть опущена путем трактовки параметра обработчика как псевдонима объекта исключения, если смысл программы останется неизменным за исключением выполнения конструкторов и деструкторов для аргумента обработчика.

• В сопрограммах , копия параметра сопрограммы может быть опущена. В этом случае ссылки на эту копию заменяются ссылками на соответствующий параметр, если смысл программы останется неизменным за исключением выполнения конструктора и деструктора для объекта-копии параметра.

Если первый параметр выбранного конструктора является rvalue-ссылкой на тип объекта, уничтожение этого объекта происходит, когда цель была бы уничтожена. В противном случае уничтожение происходит в более поздний из моментов времени, когда два объекта были бы уничтожены без оптимизации.

Семантика prvalue ("гарантированное устранение копирования")

Начиная с C++17, prvalue не материализуется до тех пор, пока это не потребуется, и затем он конструируется непосредственно в хранилище своего конечного назначения. Это иногда означает, что даже когда синтаксис языка визуально предполагает копирование/перемещение (например, copy initialization ), никакое копирование/перемещение не выполняется — что означает, что тип вообще не должен иметь доступного конструктора копирования/перемещения. Примеры включают:

• Инициализация возвращаемого объекта в return statement , когда операнд является prvalue того же типа класса (игнорируя cv-qualification ), что и возвращаемый тип функции:

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
{

Деструктор возвращаемого типа должен быть доступен в точке оператора return и не удален, даже если объект T не уничтожается.

• При инициализации объекта, когда выражение инициализатора является prvalue того же типа класса (игнорируя cv-qualification ), что и тип переменной:

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

Это может применяться только когда известно, что инициализируемый объект не является потенциально перекрывающимся подобъектом:

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

Примечание: Это правило не определяет оптимизацию, и Стандарт формально не описывает его как "copy elision" (потому что ничего не устраняется). Вместо этого, спецификация основного языка C++17 для prvalues и temporaries фундаментально отличается от предыдущих редакций C++: больше нет временного объекта для копирования/перемещения. Другой способ описать механику C++17 — "передача нематериализованного значения" или "отложенная материализация временного объекта": prvalues возвращаются и используются без материализации временного объекта.

В операторе return или выражении throw , если компилятор не может выполнить copy elision, но условия для copy elision выполнены, или были бы выполнены за исключением того, что источник является параметром функции, компилятор попытается использовать move constructor, даже если исходный операнд обозначен lvalue (до C++23) исходный операнд будет рассматриваться как rvalue (начиная с C++23) ; подробности см. в return statement .

В constant expression и constant initialization copy elision никогда не выполняется.

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