Устранение копирования

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

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

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

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

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

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

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
}

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

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

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

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

В константных выражениях и при константной инициализации устранение копирования никогда не выполняется.

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