Arithmetic operators

Возвращает результат указанной арифметической операции.

Общее объяснение

Все встроенные арифметические операторы вычисляют результат определённой арифметической операции и возвращают его. Аргументы при этом не изменяются.

Преобразования

Если операнд, переданный встроенному арифметическому оператору, имеет целочисленный тип или тип неограниченного перечисления, то до выполнения любых других действий (но после преобразования lvalue-to-rvalue, если применимо) операнд подвергается integral promotion . Если операнд имеет тип массива или функции, применяются преобразования array-to-pointer и function-to-pointer .

Для бинарных операторов (за исключением сдвигов), если продвинутые операнды имеют разные типы, применяются обычные арифметические преобразования .

Переполнения

Арифметика беззнаковых целых чисел всегда выполняется по модулю 2 n
где n — количество битов в данном целом числе. Например, для unsigned int , добавление единицы к UINT_MAX даёт ​ 0 ​ , а вычитание единицы из ​ 0 ​ даёт UINT_MAX .

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

• он переносится в соответствии с правилами представления (обычно дополнительный код ),
• он вызывает ловушку — на некоторых платформах или из-за опций компилятора (например, -ftrapv в GCC и Clang),
• он насыщается до минимального или максимального значения (на многих ЦСП),
• он полностью оптимизируется компилятором .

Окружение с плавающей точкой

Если #pragma STDC FENV_ACCESS поддерживается и установлен в ON , все операторы арифметики с плавающей точкой подчиняются текущему направлению округления и сообщают об ошибках арифметики с плавающей точкой, как указано в math_errhandling , за исключением случаев, когда они являются частью статической инициализации (в этом случае исключения с плавающей точкой не вызываются, а режим округления установлен на ближайшее значение).

Сокращение операций с плавающей точкой

Если только #pragma STDC FP_CONTRACT не поддерживается и не установлен в значение OFF , вся арифметика с плавающей точкой может выполняться так, как если бы промежуточные результаты имели бесконечный диапазон и точность, то есть допускаются оптимизации, исключающие ошибки округления и исключения с плавающей точкой. Например, C++ позволяет реализовать ( x * y ) + z с помощью одной инструкции FMA процессора или оптимизировать a = x * x * x * x ; как tmp = x * x ; a = tmp * tmp .

Не связанные с контрактными вычислениями, промежуточные результаты операций с плавающей запятой могут иметь диапазон и точность, отличные от указанных их типом, см. FLT_EVAL_METHOD .

Формально, стандарт C++ не дает никаких гарантий относительно точности операций с плавающей запятой.

Унарные арифметические операторы

Унарные арифметические операторы имеют следующий вид

Унарные операторы + и - имеют более высокий приоритет , чем все бинарные арифметические операторы, поэтому выражение не может содержать бинарные арифметические операторы на верхнем уровне. Эти операторы ассоциируются справа налево:

+a - b; // эквивалентно (+a) - b, НЕ +(a - b)
-c + d; // эквивалентно (-c) + d, НЕ -(c + d)
+-e; // эквивалентно +(-e), унарный + является пустой операцией, если "e" — встроенный тип
     // поскольку все возможные преобразования выполняются уже во время отрицания

Встроенные унарные арифметические операторы

Перегрузки

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

#include <iostream>
int main()
{
    char c = 0x6a;
    int n1 = 1;
    unsigned char n2 = 1;
    unsigned int n3 = 1;
    std::cout << "char: " << c << " int: " << +c << "\n"
                 "-1, where 1 is signed: " << -n1 << "\n"
                 "-1, where 1 is unsigned char: " << -n2 << "\n"
                 "-1, where 1 is unsigned int: " << -n3 << '\n';
    char a[3];
    std::cout << "size of array: " << sizeof a << "\n"
                 "size of pointer: " << sizeof +a << '\n';
}

char: j int: 106
-1, where 1 is signed: -1
-1, where 1 is unsigned char: -1
-1, where 1 is unsigned int: 4294967295
size of array: 3
size of pointer: 8

Аддитивные операторы

Аддитивные операторы имеют следующий вид

Бинарные операторы + и - имеют более высокий приоритет , чем все остальные бинарные арифметические операторы, за исключением * , / и % . Эти операторы ассоциируются слева направо:

a + b * c;  // эквивалентно a + (b * c),  НЕ (a + b) * c
d / e - f;  // эквивалентно (d / e) - f,  НЕ d / (e - f)
g + h >> i; // эквивалентно (g + h) >> i, НЕ g + (h >> i)
j - k + l - m; // эквивалентно ((j - k) + l) - m

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

Для встроенных бинарных операторов плюс и минус оба операнда lhs и rhs должны быть prvalues, и должно выполняться одно из следующих условий:

• Оба операнда имеют арифметический тип или тип неограниченного перечисления. В этом случае usual arithmetic conversions применяются к обоим операндам.
• Ровно один операнд имеет целочисленный тип или тип неограниченного перечисления. В этом случае к этому операнду применяется integral promotion.

В оставшейся части описания в этом разделе термины "операнд(ы)", lhs и rhs относятся к преобразованным или продвинутым операндам.

Если оба операнда имеют тип с плавающей запятой, и тип поддерживает арифметику IEEE с плавающей запятой (см. std::numeric_limits::is_iec559 ):

• Если один операнд — NaN, результат — NaN.
• Бесконечность минус бесконечность дает NaN, и FE_INVALID устанавливается.
• Бесконечность плюс отрицательная бесконечность дает NaN, и FE_INVALID устанавливается.

Арифметика указателей

Когда выражение J целочисленного типа прибавляется к выражению P типа указатель или вычитается из него, результат имеет тип P .

• Если P вычисляется в нулевое значение указателя и J вычисляется в ​ 0 ​ , результатом является нулевое значение указателя.
• В противном случае, если P указывает на i -й элемент массива x с n элементами, и значение J равно j , то P увеличивается или уменьшается следующим образом:

• Выражения P + J и J + P

• указывают на i+j -й элемент x , если i + j находится в диапазоне [ ​ 0 ​ , n ) , и
• являются указателями за последним элементом x , если i + j равно n .

• Выражение P - J

• указывает на i-j -й элемент x , если i - j находится в диапазоне [ ​ 0 ​ , n ) , и
• является указателем за последним элементом x , если i - j равно n .

• Другие значения j приводят к неопределённому поведению.

• В противном случае, если P указывает на полный объект, подобъект базового класса или подобъект-член y , при заданном значении J как j , P увеличивается или уменьшается следующим образом:

• Выражения P + J и J + P

• указывают на y если j равно ​ 0 ​ , и
• являются указателями за конец y если j равно 1 .

• Выражение P - J

• указывает на y если j равно ​ 0 ​ , и
• является указателем за конец y если j равно - 1 .

• Другие значения j приводят к неопределённому поведению.

• В противном случае, если P является указателем за концом объекта z , при заданном значении J как j :

• Если z является массивом с n элементами, P добавляется или вычитается следующим образом:

• Выражения P + J и J + P

• указывают на n+j -й элемент z , если n + j находится в диапазоне [ ​ 0 ​ , n ) , и
• являются указателями за последний элемент z , если j равен ​ 0 ​ .

• Выражение P - J

• указывает на n-j -й элемент z , если n - j находится в диапазоне [ ​ 0 ​ , n ) , и
• является указателем за последний элемент z , если j равен ​ 0 ​ .

• Другие значения j приводят к неопределённому поведению.

• В противном случае, P добавляется или вычитается следующим образом:

• Выражения P + J и J + P

• указывают на z , если j равен - 1 , и
• являются указателями за конец z , если j равен ​ 0 ​ .

• Выражение P - J

• указывает на z , если j равен 1 , и
• является указателем за конец z , если j равен ​ 0 ​ .

• Другие значения j приводят к неопределённому поведению.

• В противном случае поведение не определено.

Когда два указательных выражения P и Q вычитаются, тип результата — std::ptrdiff_t .

• Если P и Q оба вычисляются в нулевые указатели , результат равен ​ 0 ​ .
• В противном случае, если P и Q указывают соответственно на i -й и j -й элементы массива одного и того же объекта массива x , выражение P - Q имеет значение i − j .

• Если i − j не может быть представлено типом std::ptrdiff_t , поведение не определено.

• В противном случае, если P и Q указывают на один и тот же полный объект, подобъект базового класса или подобъект-член, результатом будет ​ 0 ​ .
• В противном случае поведение не определено.

Эти операторы арифметики указателей позволяют указателям удовлетворять требованиям LegacyRandomAccessIterator .

Для сложения и вычитания, если P или Q имеют тип «указатель на (возможно cv-квалифицированный) T », где T и тип элемента массива не являются подобными , поведение не определено:

int arr[5] = {1, 2, 3, 4, 5};
unsigned int *p = reinterpret_cast<unsigned int*>(arr + 1);
unsigned int k = *p; // OK, значение "k" равно 2
unsigned int *q = p + 1; // неопределенное поведение: "p" указывает на int, а не на unsigned int

Перегрузки

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

где LR является результатом обычных арифметических преобразований над L и R .

#include <iostream>
int main()
{
    char c = 2;
    unsigned int un = 2;
    int n = -10;
    std::cout << " 2 + (-10), where 2 is a char    = " << c + n << "\n"
                 " 2 + (-10), where 2 is unsigned  = " << un + n << "\n"
                 " -10 - 2.12  = " << n - 2.12 << '\n';
    char a[4] = {'a', 'b', 'c', 'd'};
    char* p = &a[1];
    std::cout << "Pointer addition examples: " << *p << *(p + 2)
              << *( 2 + p) << *(p - 1) << '\n';
    char* p2 = &a[4];
    std::cout << "Pointer difference: " << p2 - p << '\n';
}

 2 + (-10), where 2 is a char    = -8
 2 + (-10), where 2 is unsigned  = 4294967288
 -10 - 2.12  = -12.12
Pointer addition examples: bdda
Pointer difference: 3

Мультипликативные операторы

Выражения мультипликативных операторов имеют вид

Мультипликативные операторы имеют более высокий приоритет чем все остальные бинарные арифметические операторы. Эти операторы ассоциируются слева направо:

a + b * c;  // эквивалентно a + (b * c),  НЕ (a + b) * c
d / e - f;  // эквивалентно (d / e) - f,  НЕ d / (e - f)
g % h >> i; // эквивалентно (g % h) >> i, НЕ g % (h >> i)
j * k / l % m; // эквивалентно ((j * k) / l) % m

Встроенные мультипликативные операторы

Для встроенных операторов умножения и деления оба операнда должны иметь арифметический тип или тип неограниченного перечисления. Для встроенного оператора остатка оба операнда должны иметь целочисленный тип или тип неограниченного перечисления. Обычные арифметические преобразования применяются к обоим операндам.

В оставшейся части описания в этом разделе "операнд(ы)", lhs и rhs относятся к преобразованным операндам.

Примечание: До того, как CWG issue 614 была решена ( N2757 ), если один или оба операнда бинарного оператора % были отрицательными, знак остатка определялся реализацией, поскольку он зависит от направления округления при целочисленном делении. Функция std::div обеспечивала хорошо определённое поведение в этом случае.

Примечание: для вещественного остатка от деления смотрите std::remainder и std::fmod .

Перегрузки

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

где LRx является результатом обычных арифметических преобразований над Lx и Rx .

#include <iostream>
int main()
{
    char c = 2;
    unsigned int un = 2;
    int  n = -10;
    std::cout << "2 * (-10), where 2 is a char    = " << c * n << "\n"
                 "2 * (-10), where 2 is unsigned  = " << un * n << "\n"
                 "-10 / 2.12  = " << n / 2.12 << "\n"
                 "-10 / 21  = " << n / 21 << "\n"
                 "-10 % 21  = " << n % 21 << '\n';
}

2 * (-10), where 2 is a char    = -20
2 * (-10), where 2 is unsigned  = 4294967276
-10 / 2.12  = -4.71698
-10 / 21  = 0
-10 % 21  = -10

Побитовые логические операторы

Выражения с побитовыми логическими операторами имеют вид

Оператор побитового НЕ имеет более высокий приоритет , чем все бинарные арифметические операторы. Он ассоциируется справа налево:

~a - b; // эквивалентно (~a) - b, НЕ ~(a - b)
~c * d; // эквивалентно (~c) * d, НЕ ~(c * d)
~-e; // эквивалентно ~(-e)

В грамматике существует неоднозначность, когда ~ следует за именем типа или спецификатором decltype (начиная с C++11) : это может быть либо operator~, либо начало идентификатора деструктора ). Неоднозначность разрешается путём трактовки ~ как operator~. ~ может начинать идентификатор деструктора только в тех случаях, когда формирование operator~ синтаксически невозможно.

Все остальные побитовые логические операторы имеют более низкий приоритет , чем все остальные бинарные арифметические операторы. Побитовое И имеет более высокий приоритет, чем побитовое исключающее ИЛИ, которое имеет более высокий приоритет, чем побитовое ИЛИ. Они ассоциируются слева направо:

a & b * c;  // эквивалентно a & (b * c),  НЕ (a & b) * c
d / e ^ f;  // эквивалентно (d / e) ^ f,  НЕ d / (e ^ f)
g << h | i; // эквивалентно (g << h) | i, НЕ g << (h | i)
j & k & l; // эквивалентно (j & k) & l
m | n ^ o  // эквивалентно m | (n ^ o)

Встроенные побитовые логические операторы

Для встроенного побитового оператора NOT, rhs должно быть prvalue целочисленного типа или неограниченного перечисления, и над rhs выполняется целочисленное продвижение. Для других встроенных побитовых логических операторов оба операнда должны иметь целочисленный тип или тип неограниченного перечисления, и над обоими операндами выполняются обычные арифметические преобразования .

В оставшейся части описания в этом разделе "операнд(ы)", lhs и rhs относятся к преобразованным или продвинутым операндам.

Перегрузки

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

где LR является результатом обычных арифметических преобразований над L и R .

#include <bitset>
#include <cstdint>
#include <iomanip>
#include <iostream>
int main()
{
    std::uint16_t mask = 0x00f0;
    std::uint32_t x0 = 0x12345678;
    std::uint32_t x1 = x0 | mask;
    std::uint32_t x2 = x0 & ~mask;
    std::uint32_t x3 = x0 & mask;
    std::uint32_t x4 = x0 ^ mask;
    std::uint32_t x5 = ~x0;
    using bin16 = std::bitset<16>;
    using bin32 = std::bitset<32>;
    std::cout << std::hex << std::showbase
              << "Маска: " << mask << std::setw(49) << bin16(mask) << "\n"
                 "Значение: " << x0 << std::setw(42) << bin32(x0) << "\n"
                 "Установка битов: " << x1 << std::setw(35) << bin32(x1) << "\n"
                 "Сброс битов: " << x2 << std::setw(34) << bin32(x2) << "\n"
                 "Выбор битов: " << x3 << std::setw(39) << bin32(x3) << "\n"
                 "Исключающее ИЛИ: " << x4 << std::setw(35) << bin32(x4) << "\n"
                 "Инверсия битов: " << x5 << std::setw(33) << bin32(x5) << '\n';
}

Маска: 0xf0                                 0000000011110000
Значение: 0x12345678          00010010001101000101011001111000
Установка битов: 0x123456f8   00010010001101000101011011111000
Сброс битов: 0x12345608  00010010001101000101011000001000
Выбор битов: 0x70       00000000000000000000000001110000
Исключающее ИЛИ: 0x12345688   00010010001101000101011010001000
Инверсия битов: 0xedcba987 11101101110010111010100110000111

Побитовые операторы сдвига

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

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

a >> b * c;  // эквивалентно a >> (b * c),  НЕ (a >> b) * c
d << e & f;  // эквивалентно (d << e) & f,  НЕ d << (e & f)
g << h >> i; // эквивалентно (g << h) >> i, НЕ g << (h >> i)

Встроенные побитовые операторы сдвига

Для встроенных побитовых операторов сдвига оба операнда должны быть prvalue целочисленного типа или типа неограниченного перечисления. Над обоими операндами выполняются целочисленные продвижения.

В оставшейся части описания в этом разделе "операнд(ы)", a , b , lhs и rhs относятся к преобразованным или повышенным операндам.

Если значение rhs отрицательно или не меньше количества битов в lhs , поведение не определено.

Тип результата совпадает с типом lhs .

Перегрузки

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

#include <iostream>
enum { ONE = 1, TWO = 2 };
int main()
{
    std::cout << std::hex << std::showbase;
    char c = 0x10;
    unsigned long long ull = 0x123;
    std::cout << "0x123 << 1 = " << (ull << 1) << "\n"
                 "0x123 << 63 = " << (ull << 63) << "\n" // переполнение в беззнаковом
                 "0x10 << 10 = " << (c << 10) << '\n';   // char продвигается до int
    long long ll = -1000;
    std::cout << std::dec << "-1000 >> 1 = " << (ll >> ONE) << '\n';
}

0x123 << 1 = 0x246
0x123 << 63 = 0x8000000000000000
0x10 << 10 = 0x4000
-1000 >> 1 = -500

Стандартная библиотека

Арифметические операторы перегружены для многих типов стандартной библиотеки.

Унарные арифметические операторы

Аддитивные операторы

Мультипликативные операторы

Побитовые логические операторы

Побитовые операторы сдвига

Операторы вставки/извлечения потоков

В стандартной библиотеке побитовые операторы сдвига часто перегружаются с потоком ввода-вывода ( std:: ios_base & или одним из классов, производных от него) в качестве как левого операнда, так и типа возвращаемого значения. Такие операторы известны как операторы вставки в поток и операторы извлечения из потока :

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

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

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

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

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