Assignment operators

Операторы присваивания изменяют значение объекта.

Определения

Копирующее присваивание заменяет содержимое объекта a копией содержимого b ( b не изменяется). Для классовых типов это выполняется специальной функцией-членом, описанной в операторе копирующего присваивания .

Для неклассовых типов копирующее и перемещающее присваивание неразличимы и называются прямым присваиванием .

Составное присваивание заменяет содержимое объекта a результатом бинарной операции между предыдущим значением a и значением b .

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

Выражения присваивания имеют вид

1. ↑ target-expr должен иметь более высокий приоритет чем выражение присваивания.
2. ↑ new-value не может быть выражением с запятой, поскольку его приоритет ниже.

Встроенный оператор простого присваивания

Для встроенного простого присваивания target-expr должен быть изменяемым lvalue.

Объект, на который ссылается target-expr , модифицируется путем замены его значения на результат new-value . Если на который ссылается объект имеет целочисленный тип T , и результат new-value имеет соответствующий знаковый/беззнаковый целочисленный тип, значение объекта заменяется значением типа T с тем же представлением значения результата new-value .

Результатом встроенного простого присваивания является lvalue типа target-expr , ссылающееся на target-expr . Если target-expr является битовым полем , результат также является битовым полем.

Присваивание из выражения

Если new-value является выражением, оно неявно преобразуется в cv-неквалифицированный тип target-expr . Когда target-expr является битовым полем, которое не может представить значение выражения, результирующее значение битового поля определяется реализацией.

Если target-expr и new-value указывают на перекрывающиеся объекты, поведение не определено (если только перекрытие не является точным и тип не совпадает).

#include <complex>
std::complex<double> z;
z = {1, 2};  // meaning z.operator=({1, 2})
z += {1, 2}; // meaning z.operator+=({1, 2})
int a, b;
a = b = {1}; // meaning a = b = 1;
a = {1} = b; // syntax error

В разрешении перегрузки для пользовательских операторов , для каждого типа T , следующие сигнатуры функций участвуют в разрешении перегрузки:

Для каждого типа перечисления или указателя на член T , опционально с квалификатором volatile, следующая сигнатура функции участвует в разрешении перегрузки:

Для каждой пары A1 и A2 , где A1 является арифметическим типом (опционально с квалификатором volatile) и A2 является продвинутым арифметическим типом, следующая сигнатура функции участвует в разрешении перегрузки:

Встроенный составной оператор присваивания

Поведение каждого встроенного составного присваивания target-expr op  = new-value точно такое же, как поведение выражения target-expr = target-expr op new-value , за исключением того, что target-expr вычисляется только один раз.

Требования к target-expr и new-value для встроенных операторов простого присваивания также применяются. Кроме того:

• Для + = и - = тип target-expr должен быть арифметическим типом или указателем на (возможно cv-квалифицированный) полностью определенный объектный тип .
• Для всех остальных составных операторов присваивания тип target-expr должен быть арифметическим типом.

В разрешении перегрузки для пользовательских операторов , для каждой пары A1 и A2 , где A1 является арифметическим типом (опционально с volatile-квалификатором) и A2 является продвинутым арифметическим типом, следующие сигнатуры функций участвуют в разрешении перегрузки:

Для каждой пары I1 и I2 , где I1 является целочисленным типом (опционально с квалификатором volatile) и I2 является продвинутым целочисленным типом, следующие сигнатуры функций участвуют в разрешении перегрузки:

Для каждого опционально cv-квалифицированного типа объекта T следующие сигнатуры функций участвуют в разрешении перегрузки:

Пример

#include <iostream>
int main()
{
    int n = 0;        // не присваивание
    n = 1;            // прямое присваивание
    std::cout << n << ' ';
    n = {};           // инициализация нулем, затем присваивание
    std::cout << n << ' ';
    n = 'a';          // целочисленное повышение, затем присваивание
    std::cout << n << ' ';
    n = {'b'};        // явное приведение, затем присваивание
    std::cout << n << ' ';
    n = 1.0;          // преобразование с плавающей точкой, затем присваивание
    std::cout << n << ' ';
//  n = {1.0};        // ошибка компилятора (сужающее преобразование)
    int& r = n;       // не присваивание
    r = 2;            // присваивание через ссылку
    std::cout << n << ' ';
    int* p;
    p = &n;           // прямое присваивание
    p = nullptr;      // преобразование в нулевой указатель, затем присваивание
    std::cout << p << ' ';
    struct { int a; std::string s; } obj;
    obj = {1, "abc"}; // присваивание из списка инициализации в фигурных скобках
    std::cout << obj.a << ':' << obj.s << '\n';
}

1 0 97 98 1 2 (nil) 1:abc

Отчеты о дефектах

Следующие отчеты об изменениях в поведении, содержащие описания дефектов, были применены ретроактивно к ранее опубликованным стандартам C++.

Смотрите также

Приоритет операторов

Перегрузка операторов