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

Оператор присваивания копирования это нешаблонная нестатическая функция-элемент с именем operator=, которую можно вызвать с аргументом того же классового типа и которая копирует содержимое аргумента, не изменяя аргумент.

[править] Синтаксис

Формальный синтаксис оператора присваивания копированием смотрите в разделе объявление функции. Список синтаксисов ниже демонстрирует толь��о подмножество всех допустимых синтаксисов операторов копирования.

[править] Объяснение

struct X
{
    X& operator=(X& other);     // оператор присваивания копированием
    X operator=(X other);       // разрешена передача по значению
//  X operator=(const X other); // Ошибка: неверный тип параметра
};
 
union Y
{
    // Операторы присваивания копирования могут иметь синтаксис,
    // не указанный выше, при условии, что они следуют общему
    // синтаксису объявления функции и не нарушают ограничения, перечисленные выше
    auto operator=(Y& other) -> Y&;       // OK: конечный тип возвращаемого значения
    Y& operator=(this Y& self, Y& other); // OK: явный параметр объекта
//  Y& operator=(Y&, int num = 1);        // Ошибка: есть другие параметры,
                                          // не являющиеся объектами
};

Оператор присваивания копированием вызывается всякий раз, когда он выбирается разрешением перегрузки, например когда объект появляется в левой части выражения присваивания.

[править] Неявно объявленный оператор присваивания копированием

Если для классового типа не предусмотрены пользовательские операторы присваивания копированием, компилятор всегда будет объявлять их как inline public элемент класса. Этот неявно объявленный оператор присваивания копированием имеет вид T& T::operator=(const T&), если выполняются все следующие условия:

• каждый прямой базовый класс B класса T имеет оператор присваивания копированием, параметрами которого являются B или const B& или const volatile B&;
• каждый нестатический элемент данных M из T классового типа или массива классового типа имеет оператор присваивания копированием, параметром которого является M или const M& или const volatile M&.

Иначе неявно объявленный оператор присваивания копированием объявляется как T& T::operator=(T&).

Из-за этих правил неявно объявленный оператор присваивания копированиtv не может привязываться к аргументу volatile lvalue.

Класс может иметь несколько операторов присваивания копированием, например как T& T::operator=(T&) так и T& T::operator=(T). Если присутствуют некоторые пользовательские операторы присваивания копированием, пользователь всё равно может принудительно сгенерировать неявно объявленный оператор присваивания копированием ключевым словом default. (начиная с C++11)

Неявно объявленный (или заданный по умолчанию при первом объявлении) оператор присваивания копированием имеет спецификацию исключения, как описано в спецификации динамических исключений (до C++17)спецификации noexcept (начиная с C++17)

Поскольку оператор присваивания копированием всегда объявляется для любого класса, оператор присваивания базового класса всегда скрыт. Если для ввода оператора присваивания из базового класса используется using-объявление и его тип аргумента может быть таким же, как тип аргумента неявного оператора присваивания производного класса, using-объявление также скрыто неявным объявлением.

[править] Неявно определённый оператор присваивания копированием

Если неявно объявленный оператор присваивания копированием не является ни удалённым, ни тривиальным, он определяется (то есть тело функции генерируется и компилируется) компилятором, если используется odr или это необходимо для константной оценки (начиная с C++14). Для типов объединения неявно определённое присваивание копированием копирует представление объекта (как std::memmove). Для классовых типов не объединений (class и struct) оператор выполняет поэлементное копирование базовых и нестатических элементов объекта в порядке их инициализации, используя встроенное присваивание для скаляров и оператор присваивания копированием для классовых типов.

[править] Удалённый оператор присваивания копированием

Неявно объявленный или явно заданный по умолчанию (начиная с C++11) оператор копирования копированием для класса T не определён (до C++11)определяется как удалённый (начиная с C++11), если выполняется любое из следующих условий:

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

• не приводит к появлению пригодного для использования кандидата, или
• в случае, если подобъект является вариантным элементом, выбирает нетривиальную функцию.

[править] Тривиальный оператор присваивания копированием

Оператор присваивания копированием для класса T тривиален, если выполняются все следующие условия:

• он не предоставляется пользователем (это означает, что он неявно определён или установлен по умолчанию);
• T не имеет виртуальных функций-элементов;
• T не имеет виртуальных базовых классов;
• оператор присваивания копированием, выбранный для каждого прямого базового класса класса T, тривиален;
• оператор присваивания копированием, выбранный для каждого элемента T нестатического классового типа (или массива классовых типов), является тривиальным.

Тривиальный оператор присваивания копированием создаёт копию представления объекта, как если при выполнении std::memmove. Все типы данных, совместимые с языком C (типы POD), тривиально присваиваются копированием.

[править] Доступный оператор присваивания копированием

Тривиальность подходящих операторов присваивания копированием определяет, является ли класс тривиально копируемым типом.

[править] Примечание

Если предоставлены операторы присваивания копированием и перемещением, разрешение перегрузки выбирает присваивание перемещением, если аргумент является rvalue (или prvalue, например безымянное временное значение или xvalue, например результат std::move), и выбирает присваивание копированием, если аргумент является lvalue (именованный объект или функция/оператор, возвращающая ссылку на lvalue). Если обеспечено только присваивание копированием, все категории аргументов выбирают его (при условии, что аргумент принимается по значению или как ссылка на const, поскольку значения rvalue могут привязываться к ссылкам const), что делает присваивание копированием запасным вариантом для присваивания перемещением, когда перемещение недоступно.

Не указано, назначаются ли виртуальные подобъекты базового класса, доступные более чем через один путь в решётке наследования, более одного раза с помощью неявно определённого оператора присваивания копированием (то же самое относится к присваиванию перемещением).

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

[править] Пример

#include <algorithm>
#include <iostream>
#include <memory>
#include <string>
 
struct A
{
    int n;
    std::string s1;
    A() = default;
    A(A const&) = default;
    // определяемое пользователем присваивание копированием (идиома копирования и замены)
    A& operator=(A other)
    {
        std::cout << "присваивание копированием А\n";
        std::swap(n, other.n);
        std::swap(s1, other.s1);
        return *this;
    }
};
 
struct B : A
{
    std::string s2;
    // неявно определённое присваивание копированием
};
 
struct C
{
    std::unique_ptr<int[]> data;
    std::size_t size;
    // определяемое пользователем присваивание копированием (не идиома копирования и
    // замены)
    // примечание: копирование и замена всегда приводит к перераспределению ресурсов
    C& operator=(const C& other)
    {
        if (this != &other) // не самоприсваивание
        {
            if (size != other.size) // ресурс нельзя использовать повторно
            {
                data.reset(new int[other.size]);
                size = other.size;
            }
            std::copy(&other.data[0], &other.data[0] + size, &data[0]);
        }
        return *this;
    }
};
 
int main()
{
    A a1, a2;
    std::cout << "a1 = a2 вызывает ";
    a1 = a2; // определяемое пользователем присваивание копированием
 
    B b1, b2;
    b2.s1 = "foo";
    b2.s2 = "bar";
    std::cout << "b1 = b2 вызывает ";
    b1 = b2; // неявно определённое присваивание копированием
    std::cout << "b1.s1 = " << b1.s1 << "; b1.s2 = " << b1.s2 << '\n';
}

a1 = a2 вызывает присваивание копированием A
b1 = b2 вызывает присваивание копированием A
b1.s1 = foo; b1.s2 = bar

[править] Отчёты о дефектах

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

[править] Смотрите также

• конструктор преобразования
• конструктор копирования
• пропуск копирования
• конструктор по умолчанию
• деструктор
• explicit
• инициализация
  • агрегатная инициализация
  • константная инициализация
  • инициализация копированием
  • инициализация по умолчанию
  • прямая инициализация
  • список инициализаторов
  • инициализация списком
  • инициализация ссылки
  • инициализация значением
  • инициализация нулём
• присваивание перемещением
• конструктор перемещения
• new