Пространства имён
Варианты
Действия

Assignment operators

Материал из cppreference.com
< cpp‎ | language

 
 
Язык С++
Общие темы
Управление программой
Операторы условного выполнения
Операторы повторения
Операторы перехода
Функции
объявление функции
объявление лямбда-функции
шаблон функции
спецификатор inline
спецификаторы исключений (устарело)
спецификатор noexcept (C++11)
Исключения
Пространства имён
объявление пространства имён
псевдонимы пространства имён
Типы
спецификатор decltype (C++11)
Спецификаторы
cv-спецификаторы
спецификаторы продолжительности хранения
спецификатор constexpr (C++11)
спецификатор auto (C++11)
спецификатор alignas (C++11)
Инициализация
Литералы
Выражения
Утилиты
Типы
typedef-объявление
объявление псевдонима типа (C++11)
атрибуты (C++11)
Приведения типов
неявные преобразования
const_cast-преобразование
static_cast-преобразование
dynamic_cast-преобразование
reinterpret_cast-преобразование
C-подобное и функциональное приведение типов
Выделение памяти
Классы
Особые свойства классовых функций
Специальные функции-члены
Шаблоны
шаблон класса
шаблон функции
специализация шаблона
упакованные параметры (C++11)
Разное
Ассемблерные вставки
 
Операторы присваивания изменить значение объекта.
Оригинал:
Assignment operators modify the value of the object.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Operator name Syntax Over​load​able Prototype examples (for class T)
Inside class definition Outside class definition
basic assignment a = b Да T& T::operator =(const T2& b); N/A
move assignment (C++11) a = rvalue Да T& T::operator =(T2&& b); N/A
addition assignment a += b Да T& T::operator +=(const T2& b); T& operator +=(T& a, const T2& b);
subtraction assignment a -= b Да T& T::operator -=(const T2& b); T& operator -=(T& a, const T2& b);
multiplication assignment a *= b Да T& T::operator *=(const T2& b); T& operator *=(T& a, const T2& b);
division assignment a /= b Да T& T::operator /=(const T2& b); T& operator /=(T& a, const T2& b);
modulo assignment a %= b Да T& T::operator %=(const T2& b); T& operator %=(T& a, const T2& b);
bitwise AND assignment a &= b Да T& T::operator &=(const T2& b); T& operator &=(T& a, const T2& b);
bitwise OR assignment a |= b Да T& T::operator |=(const T2& b); T& operator |=(T& a, const T2& b);
bitwise XOR assignment a ^= b Да T& T::operator ^=(const T2& b); T& operator ^=(T& a, const T2& b);
bitwise left shift assignment a <<= b Да T& T::operator <<=(const T2& b); T& operator <<=(T& a, const T2& b);
bitwise right shift assignment a >>= b Да T& T::operator >>=(const T2& b); T& operator >>=(T& a, const T2& b);
'Примечание'
Оригинал:
Notes
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Все встроенные операторы присваивания вернуться *this, и большинство пользовательских перегрузки также вернуть *this так, что пользовательские операторы могут быть использованы таким же образом, как и встроенные модули. Однако, в определенный пользователем оператор перегрузки, любого типа могут быть использованы в качестве возвращаемого типа (в том числе void).
    Оригинал:
    All built-in assignment operators return *this, and most user-defined overloads also return *this so that the user-defined operators can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including void).
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • T2 может быть любого типа, включая T
    Оригинал:
    T2 can be any type including T
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

Содержание

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

' Копия назначение оператора заменяет содержимое объекта a с копией содержимого b (b не изменены). Для класса типов, это особая функция-член, описанная в скопируйте оператор присваивания.
Оригинал:
copy assignment operator replaces the contents of the object a with a copy of the contents of b (b is no modified). For class types, this is a special member function, described in скопируйте оператор присваивания.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
' Ход назначение оператора заменяет содержимое объекта a с содержанием b, избегая копирования, если возможно (b может быть изменен). Для класса типов, это особая функция-член, описанная в двигаться оператор присваивания. (начиная с C++11)
Оригинал:
move assignment operator replaces the contents of the object a with the contents of b, avoiding copying if possible (b may be modified). For class types, this is a special member function, described in двигаться оператор присваивания. (начиная с C++11)
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Для не-классами, копировать и перемещать назначения, неразличимы и называется' прямому назначению.
Оригинал:
For non-class types, copy and move assignment are indistinguishable and are referred to as direct assignment.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Соединения операторов присваивания заменить содержимое содержимого объекта a с результатом бинарной операции между предыдущим значением a и значение b.
Оригинал:
compound assignment operators replace the contents the contents of the object a with the result of a binary operation between the previous value of a and the value of b.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

[править] Встроенная прямому назначению

Для каждого типа T, следующие функции подписи участие в разрешении перегрузки
Оригинал:
For every type T, the following function signatures participate in overload resolution:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
T*& operator=(T*&, T*);
T*volatile & operator=(T*volatile &, T*);
Для каждого перечисления, либо указатель на член T типа, необязательно летучих квалифицированных, следующие функции подписи участвует в разрешении перегрузки
Оригинал:
For every enumeration or pointer to member type T, optionally volatile-qualified, the following function signature participates in overload resolution:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
T& operator=(T&, T );
Для каждой пары A1 и A2, где A1 арифметического типа (опционально летучих квалифицированным) и А2 способствовало арифметический тип, следующие функции подписи участвует в разрешении перегрузки
Оригинал:
For every pair A1 and A2, where A1 is an arithmetic type (optionally volatile-qualified) and A2 is a promoted arithmetic type, the following function signature participates in overload resolution:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
A1& operator=(A1&, A2);
Для выражения E1 любой T скалярного типа, следующие дополнительные формы выражения встроенного назначения допускается
Оригинал:
For expressions E1 of any scalar type T, the following additional forms of the builtin assignment expression are allowed:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
E1 = {}
(начиная с C++11)
E1 = {E2}
(начиная с C++11)
Примечание: выше включает в себя все не-класса типов, кроме ссылочных типов, массивов, функций типа, а также типа void, которые напрямую не назначаемыми.
Оригинал:
Note: the above includes all non-class types except reference types, array types, function types, and the type void, which are not directly assignable.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Прямые оператор присваивания ожидает модифицируемые именующее как левый операнд и возвращает именующее выявления левого операнда после модификации. Для не-классами, правый операнд первый неявно преобразованы к CV-неквалифицированный тип левого операнда, а затем его значение копируется в объект, определенный левый операнд.
Оригинал:
The direct assignment operator expects a modifiable lvalue as its left operand and returns an lvalue identifying the left operand after modification. For non-class types, the right operand is first неявно преобразованы to the cv-unqualified type of the left operand, and then its value is copied into the object identified by left operand.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Если левый операнд ссылочного типа, оператор присваивания относится к упомянутой к объекту.
Оригинал:
When the left operand is a reference type, the assignment operator applies to the referred-to object.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Если левый и правый операнды выявления перекрывающихся объектов, поведение не определено (если перекрытие точные и типа то же самое)
Оригинал:
If the left and the right operands identify overlapping objects, the behavior is undefined (unless the overlap is exact and the type is the same)
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Если правый операнд приготовился-INIT-лист
Оригинал:
If the right operand is a braced-init-list
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Выражение E1 = {} эквивалентно E1 = T(), где T это тип E1.
    Оригинал:
    the expression E1 = {} is equivalent to E1 = T(), where T is the type of E1.
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Выражение E1 = {E2} эквивалентно E1 = T(E2), где T это тип E1, за исключением того, что сужение неявные преобразования запрещены.
    Оригинал:
    the expression E1 = {E2} is equivalent to E1 = T(E2), where T is the type of E1, except that narrowing implicit conversions are prohibited.
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Для класса типов, этот синтаксис создает вызов оператор присваивания с std::initializer_list в качестве аргумента, в соответствии с правилами Список инициализации
Оригинал:
For class types, this syntax generates a call to the assignment operator with std::initializer_list as the argument, following the rules of Список инициализации
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

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

#include <iostream>
int main()
{
    int n = 0;  // not an assignment
    n = 1;      // direct asignment
    std::cout << n << ' ';
    n = {};     // zero-initialization, then assignment
    std::cout << n << ' ';
    n = 'a';    // integral promotion, then assignment
    std::cout << n << ' ';
    n = {'b'};   // explicit cast, then assignment
    std::cout << n << ' ';
    n = 1.0;    // floating-point conversion, then assignment
    std::cout << n << ' ';
//    n = {1.0}; // compiler error (narrowing conversion)
 
    int& r = n;  // not an assignment
    int* p;
 
    r = 2;       // assignment through reference
    std::cout << n << ' ';
    p = &n;      // direct assignment
    p = nullptr; // null-pointer conversion, then assignment
}

Вывод:

1 0 97 98 1 2

[править] Встроенная присваивания

Для каждой пары A1 и A2, где A1 арифметического типа (опционально летучих квалифицированным) и А2 способствовало арифметический тип, следующие функции подписи участие в разрешении перегрузки
Оригинал:
For every pair A1 and A2, where A1 is an arithmetic type (optionally volatile-qualified) and A2 is a promoted arithmetic type, the following function signatures participate in overload resolution:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
A1& operator*=(A1&, A2);
A1& operator/=(A1&, A2);
A1& operator+=(A1&, A2);
A1& operator-=(A1&, A2);
Для каждой пары I1 и I2, где I1 является неотъемлемой типа (опционально летучих квалифицированных) и I2 это способствовало интегрального типа, следующие функции подписи участие в разрешении перегрузки
Оригинал:
For every pair I1 and I2, where I1 is an integral type (optionally volatile-qualified) and I2 is a promoted integral type, the following function signatures participate in overload resolution:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
I1& operator%=(I1&, I2);
I1& operator<<=(I1&, I2);
I1& operator>>=(I1&, I2);
I1& operator&=(I1&, I2);
I1& operator^=(I1&, I2);
I1& operator|=(I1&, I2);
Для каждого необязательно резюме квалифицированных T тип объекта, следующие функции подписи участие в разрешении перегрузки
Оригинал:
For every optionally cv-qualified object type T, the following function signatures participate in overload resolution:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
T*& operator+=(T*&, std::ptrdiff_t);
T*& operator-=(T*&, std::ptrdiff_t);
T*volatile & operator+=(T*volatile &, std::ptrdiff_t);
T*volatile & operator-=(T*volatile &, std::ptrdiff_t);
{{{1}}}
Оригинал:
{{{2}}}
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

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

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

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

Общие операции
присваивание инкремент, декремент арифметические операции логические операции операции сравнения доступ к члену класса другие

a = b
a = rvalue
a += b
a -= b
a *= b
a /= b
a %= b
a &= b
a |= b
a ^= b
a <<= b
a >>= b

++a
--a
a++
a--

+a
-a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b

!a
a && b
a || b

a == b
a != b
a < b
a > b
a <= b
a >= b

a[b]
*a
&a
a->b
a.b
a->*b
a.*b

a(...)
a, b
(type) a
? :

Специальные операции

static_cast приводит один тип к другому совместимому типу
dynamic_cast приводит указатель или ссылку на виртуальный базовый класс к указателю или ссылке на производный класс
const_cast приводит тип к совместимому типу с другими cv-квалификаторами
reinterpret_cast приводит тип к несовместимому тип
new выделяет память
delete освобождает память
sizeof запрашивает размер типа
sizeof... запрашивает размер пакета параметров (начиная с C++11)
typeid запрашивает сведения о типе
noexcept проверяет может ли выражение возбудить исключение (начиная с C++11)
alignof запрашивает значение выравнивания для типа (начиная с C++11)