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

Арифметические операции

Материал из 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)
Разное
Ассемблерные вставки
 

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

Вид операции Синтаксис Перегружаемая Образец сигнатуры (для класса T)
Функция-член класса Свободная функция
унарный + +a Да T T::operator+() const; T operator+(const T &a);
унарный - -a Да T T::operator-() const; T operator-(const T &a);
сложение a + b Да T T::operator+(const T2 &b) const; T operator+(const T &a, const T2 &b);
вычитание a - b Да T T::operator-(const T2 &b) const; T operator-(const T &a, const T2 &b);
умножение a * b Да T T::operator*(const T2 &b) const; T operator*(const T &a, const T2 &b);
деление a / b Да T T::operator/(const T2 &b) const; T operator/(const T &a, const T2 &b);
взятие остатка a % b Да T T::operator%(const T2 &b) const; T operator%(const T &a, const T2 &b);
побитовое НЕ ~a Да T T::operator~() const; T operator~(const T &a);
побитовое И a & b Да T T::operator&(const T2 &b) const; T operator&(const T &a, const T2 &b);
побитовое ИЛИ a | b Да T T::operator|(const T2 &b) const; T operator|(const T &a, const T2 &b);
побитовое исключающее ИЛИ a ^ b Да T T::operator^(const T2 &b) const; T operator^(const T &a, const T2 &b);
сдвиг влево a << b Да T T::operator<<(const T2 &b) const; T operator<<(const T &a, const T2 &b);
сдвиг вправо a >> b Да T T::operator>>(const T2 &b) const; T operator>>(const T &a, const T2 &b);
Примечание
  • Все встроенные арифметические операции возвращают значения, и большинство определенных пользователем перегрузок арифметических операций также возвращают значения, так что эти перегрузки могут быть использованы таким же образом, как и встроенные операции. Однако, определенная пользователем перегрузка может иметь любой возвращаемый тип (в том числе void). В частности, перегруженные операции operator<< и operator>> для вставки и извлечения из потока ввода-вывода возвращают T&.
  • T2 может быть любого типа, включая T

Содержание

[править] Назначение

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

[править] Преобразования

Если операнд, переданный арифметической операции, целочисленного типа или перечисляемого типа без области действия, то перед любым другим действием (но после преобразования l-value в r-value преобразования, если это применимо) операнд подвергается целочисленному расширению. Если операнд является массивом или функцией, то применяется преобразование массива к указателю или функции к указателю.

Для бинарных операций (кроме операций сдвига), если операнды после расширения имеют разные типы, применяются дополнительные неявные преобразования, известные как обычные арифметические преобразования с целью получения общего типа (также может быть определен через свойство типа std::common_type). Если один из операндов имеет перечисляемый тип (до применения расширения), а другой имеет тип с плавающей запятой или перечисляемый тип, отличный от типа первого операнда, данное поведение не рекомендовано. (начиная с C++20)

  • Если один из операндов имеет перечисляемый тип с областью действия, никакого преобразования не выполняется: другой операнд и возвращаемое значение должны иметь тот же тип
  • В противном случае, если один из операндов long double, другой операнд преобразуется в long double
  • В противном случае, если один из операндов double, другой операнд преобразуется в double
  • В противном случае, если один из операндов float, другой операнд преобразуется в float
  • В противном случае, операнд имеет целый тип (поскольку типы bool, char, char16_t, char32_t, wchar_t и перечисляемый тип без области действия были расширены) и для получения общего типа применены целочисленные преобразования, а именно:
  • Если оба операнда без знака или оба со знаком, операнд с меньшим рангом преобразования преобразуется в операнд с большим рангом преобразования целых типов
  • В противном случае, если ранг преобразования операнда без знака больше или равен рангу преобразования операнда со знаком, операнд со знаком преобразуется к типу операнда без знака
  • В противном случае, если тип операнда со знаком может представить все значения типа операнда без знака, операнд без знака преобразуется к типу операнда со знаком
  • В противном случае оба операнда преобразуется к типу операнда без знака

Ранг преобразования растет в порядке bool, signed char, short, int, long, long long. Ранг любого типа без знака равен рангу соответствующего типа со знаком. Ранг char равен рангу signed char и unsigned char. Ранги char16_t, char32_t, и wchar_t равны рангам их подлежащих типов.

[править] Переполнение

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

Когда арифметическая операция над целым числом со знаком приводит к переполнению (значение результата не умещается в типе результата), то поведение не определено: может произойти циклический возврат результата к нулю (wrap-around) в соответствии с правилами представления целых чисел (как правило, представимых в дополнительном коде), может быть сгенерировано исключение (зависит от платформы или опций компилятора - например, -ftrapv в GCC и Clang) или операция может быть полностью удалена компилятором при оптимизации.

[править] Окружение для операций с плавающей точкой

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

[править] Свёртывание операций с плавающей точкой

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

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

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

[править] Унарные арифметические операции

Выражения для унарных арифметических операций имеют форму:

+ выражение (1)
- выражение (2)
1) унарный + (целочисленное расширение).
Для встроенной операции, выражение должно иметь арифметический тип, тип перечисления без области действия или тип указателя. К операнду применяется целочисленное расширение, если операнд имеет целочисленный тип или тип перечисления и оно определяет тип результата.
2) унарный - (изменение знака).
Для встроенной операции, выражение должно иметь арифметический тип или тип перечисления без области действия. К операнду применяется целочисленное расширение и оно определяет тип результата.

Встроенная операция унарный + возвращает значение своего операнда. Единственная ситуация, при которой данная операция не является пустой операцией, это когда операнд имеет целочисленный тип или перечисляемый тип без области действия и тип был изменен расширением, например, оно преобразовало char в int или, если операнд подлежит преобразованию l-value к r-value, массива к указателю, или функции к указателю.

Встроенная операция унарный - вычисляет величину своего операнда с противоположным знаком. Для беззнакового a, значение -a равно 2b
-a
, где b - число битов после расширения.

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

A operator+(A)
T* operator+(T*)
A operator-(A)
#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

[править] Аддитивные операции

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

lhs + rhs (1)
lhs - rhs (2)
1) сложение
Для встроенной операции lhs и rhs:
  • оба должны иметь арифметический тип или тип перечисления без области действия. В этом случае выполняются обычные арифметические преобразования обоих операндов, определяющие тип результата
  • или один из операндов должен быть указателем на полный объектный тип, а второй иметь целочисленный тип или тип перечисления без области действия. В этом случае тип результата будет иметь тип указателя
2) вычитание
Для встроенной операции lhs и rhs:
  • оба должны иметь арифметический тип или тип перечисления без области действия. В этом случае выполняются обычные арифметические преобразования обоих операндов, определяющие тип результата
  • lhs должен быть указателем на полный объектный тип, а rhs иметь целочисленный тип или тип перечисления без области действия. В этом случае тип результата будет иметь тип указателя
  • оба должны быть указателями на один и тот же полный объектный тип, игнорируя cv-квалификаторы. В этом случае std::ptrdiff_t будет типом результата

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

  • если один из операндов NaN, то результатом будет NaN
  • ( - ) = NaN и возбуждается исключение FE_INVALID
  • ( + ) = NaN и возбуждается исключение FE_INVALID

Если любой из операндов является указателем, то применяются следующие правила:

  • Указатель на объект не-массив рассматривается как указатель на первый элемент некоторого массива размера 1
  • Если указатель P указывает на i-й элемент массива, то выражения P+n, n+P, и P-n являются указателями того же типа, что и указатели на (i+n)-й, (n+i)-й, и (i-n)-й элемент того же массива соответственно. Результатом прибавления к указателю целого числа может быть указатель на позицию за последним элементом (то есть такой указатель P, что выражение P-1 указывает на последний элемент массива). Любые другие операции (т.е. попытки получить указатель, который не указывает на элемент того же массива или на позицию за последним элементом) ведут к неопределенному поведению
  • Если указатель P указывает на i-й элемент массива, а указатель Q указывает на j-й элемент того же массива, то выражение P-Q принимает значение i-j, если это значение умещается в тип std::ptrdiff_t. Оба операнда должны указывать на элементы одного и того же массива (или на позицию за последним элементом массива), в противном случае поведение не определено. Если результат не умещается в std::ptrdiff_t, поведение не определено.
  • Если значение 0 добавляется или вычитается из указателя, то результатом является тот же указатель. Если два указателя указывают на один и тот же объект или на позицию за последним элементом в том же массиве, или оба указателя нулевые, то результат вычитания равен (std::ptrdiff_t)0

Указатели в данных арифметических операциях удовлетворяют концепту RandomAccessIterator

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

LR operator+(L, R)
LR operator-(L, R)
T* operator+(T*, std::ptrdiff_t)
T* operator+(std::ptrdiff_t, T*)
T* operator-(T*, std::ptrdiff_t)
std::ptrdiff_t operator-(T*, 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

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

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

lhs * rhs (1)
lhs / rhs (2)
lhs % rhs (3)
1) умножение
Для встроенной операции, lhs и rhs оба должны иметь арифметический тип или тип перечисления без области действия
2) деление
Для встроенной операции, lhs и rhs оба должны иметь арифметический тип или тип перечисления без области действия
3) взятие остатка
Для встроенной операции, lhs и rhs оба должны иметь целочисленный тип или тип перечисления без области действия Для всех трёх операций выполняются обычные арифметические преобразования обоих операндов, определяющие тип результата.

Бинарная операция * выполняет умножение своих операндов (после обычных арифметических преобразований), за исключением случая умножения с плавающей точкой, при котором

  • результатом умножения NaN на любое число будет NaN
  • результатом умножения бесконечности на 0 будет NaN и возбуждается исключение FE_INVALID

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

Частное округляется в направлении, определяемом реализацией.

(до C++11)

Частное округляется в направлении 0 (дробная часть отбрасывается).

(начиная с C++11)

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

  • если операнд равен NaN, результатом будет NaN
  • результатом деления числа, не равного 0, на ±0.0 будет бесконечность со знаком и возбуждается исключение FE_DIVBYZERO
  • результатом деления 0.0 на 0.0 будет NaN и возбуждается исключение FE_INVALID

Бинарная операция % возвращает остаток целочисленного деления первого операнда на второй (после обычных целочисленных преобразований). Оба операнда должны иметь целый тип. Если значение частного a/b представимо в типе результата, то (a/b)*b + a%b == a. Если второй операнд равен 0, то поведение не определено. Если значение частного a/b не представимо в тип результата, то поведение операций a/b и a%b не определено (результат INT_MIN%-1 не определён для чисел в дополнительном коде).

Примечание: До стандарта C++11, если один или оба операнда были отрицательными, знак остатка определялся реализацией, поскольку он зависит от направления округления при целочисленном делении. Для обеспечения переносимости следует применять функцию std::div, поведение которой определено.

Примечание: Для вычисления остатка от деления чисел с плавающей точкой см. std::remainder и std::fmod.

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

LRA operator*(LA, RA)
LRA operator/(LA, RA)
LRI operator%(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

[править] Побитовые операции

Выражения для побитовых арифметических операций имеют форму:

~ rhs (1)
lhs & rhs (2)
lhs | rhs (3)
lhs ^ rhs (4)
1) побитовое НЕ
2) побитовое И
3) побитовое ИЛИ
4) побитовое исключающее ИЛИ
Для встроенных операций, lhs и rhs оба должны иметь целочисленный тип или тип перечисления без области действия. Выполняются обычные арифметические преобразования обоих операндов, определяющие тип результата.

Результатом операции ~ является побитовое НЕ (в обратном коде) значения аргумента (после расширения). Результатом операции & является значение побитового И значений операндов (после обычных арифметических преобразований). Результатом операции | является значение побитового ИЛИ значений операндов (после обычных арифметических преобразований). Результатом операции ^ является значение побитового исключающего ИЛИ (XOR) значений операндов (после обычных арифметических преобразований).

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

R operator~(R)
LR operator&(L, R)
LR operator^(L, R)
LR operator|(L, R)

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

#include <iostream>
int main()
{
    std::cout << std::hex << std::showbase;
    uint16_t mask = 0x00f0;
    uint32_t a = 0x12345678;
    std::cout << "Value: " << a << " mask: " << mask << '\n'
              << "Setting bits: " << (a | mask) << '\n'
              << "Clearing bits: " << (a & ~mask) << '\n'
              << "Selecting bits: " << (a & mask) << '\n';
}

Вывод:

Value: 0x12345678 mask: 0xf0
Setting bits: 0x123456f8
Clearing bits: 0x12345608
Selecting bits: 0x70

[править] Операции сдвига

Выражения для операций сдвига имеют форму:

lhs << rhs (1)
lhs >> rhs (2)
1) сдвиг влево lhs на rhs битов
2) сдвиг вправо lhs на rhs битов
Для встроенных операций, lhs и rhs оба должны иметь целочисленный тип или тип перечисления без области действия. Выполняются целочисленные расширения обоих операндов.

Возвращаемым типом является тип левого операнда после целочисленных расширений.

Для беззнакового a значение a << b есть остаток от деления a * 2b
на 2N
, где N - число битов в возвращаемом типе (т.е. выполняется побитовый сдвиг влево, а биты, не помещающиеся в типе результата, отбрасываются).

Для знакового и неотрицательного a, значение a << b есть a * 2b
, если оно представимо возвращаемым типом, иначе поведение не определено.

(до C++14)

Для знакового и неотрицательного a, если a * 2b
представимо в беззнаковом варианте возвращаемого типа, тогда это значение, преобразованное к типу со знаком, есть результат a << b (допустимо получение INT_MIN как 1<<31), в ином случае поведение не определено.

(начиная с C++14)

Для отрицательного a поведение a << b не определено.

Для беззнакового a и неотрицательного b со знаком, значение a >> b является целой частью a/2b
.

Для отрицательного a, значение a >> b определяется реализацией (в большинстве реализаций выполняется арифметический сдвиг вправо так, что результат остается отрицательным).

(до C++20)

Значение a << b единственно и сравнимо с a * 2b
по модулю 2N
, где N - число битов в возвращаемом типе (т.е. выполняется побитовый сдвиг влево, а биты, не помещающиеся в типе результата, отбрасываются).

Значение a >> b есть a/2b
, округленное в меньшую сторону (другими словами, сдвиг вправо знакового a это арифметический сдвиг вправо).

(начиная с C++20)

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

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

L operator<<(L, R)
L operator>>(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' // overflow in unsigned
              << "0x10 << 10 = " << (c << 10) << '\n';   // char is promoted to 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

[править] Стандартная библиотека

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

[править] Унарные арифметические операции

реализует операции унарный + и унарный -.
(public функция-член std::chrono::duration) [править]
применяют операции унарных + и - к комплексным числам
(шаблон функции) [править]
применяют унарные арифметические операции к каждому элементу valarray
(public функция-член std::valarray) [править]

[править] Аддитивные операции

выполняет операции сложения и вычитания длительности из момента времени
(шаблон функции) [править]
реализуют арифметические операции с длительностями времени
(шаблон функции) [править]
объединяет две строки или строку и символ
(шаблон функции) [править]
продвигает итератор вперед или назад
(public функция-член std::reverse_iterator)
продвигает итератор вперед или назад
(public функция-член std::move_iterator)
выполняет арифметические действия над двумя комплексными числами или комплексным числом и скаляром
(шаблон функции) [править]
применяют бинарные операторы к элементам двух std::valarray попарно, или к std::valarray и значению
(шаблон функции) [править]

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

реализуют арифметические операции с длительностями времени
(шаблон функции) [править]
выполняет арифметические действия над двумя комплексными числами или комплексным числом и скаляром
(шаблон функции) [править]
применяют бинарные операторы к элементам двух std::valarray попарно, или к std::valarray и значению
(шаблон функции) [править]

[править] Побитовые операции

изменяют элементы объекта std::bitset, применяя к ним логические операции И, ИЛИ, исключающее ИЛИ, НЕ
(public функция-член std::bitset) [править]
выполняют побитовые операции И, ИЛИ, исключающее ИЛИ с элементами двух std::bitset
(функция) [править]
применяет логическую операцию НЕ к каждому элементу std::valarray
(public функция-член std::valarray)
применяют побитовые операции И, ИЛИ, исключающее ИЛИ к элементам двух std::valarray попарно, или к элементам std::valarray и значению
(шаблон функции)

[править] Операции сдвига

применяют операции сдвига влево/вправо к элементам двух std::valarray попарно, или к элементам std::valarray и значению
(шаблон функции)
выполняют двоичный сдвиг влево/вправо элементов std::bitset
(public функция-член std::bitset)

[править] Операции вставки / извлечения из потока

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

извлекает форматированные данные из потока ввода std::basic_istream
(public функция-член std::basic_istream) [править]
извлекает форматированные данные из потока ввода std::basic_istream
(шаблон функции) [править]
вставляет форматированные данные в поток вывода std::basic_ostream
(public функция-член std::basic_ostream) [править]
вставляет символьные данные в поток вывода std::basic_ostream
(функция) [править]
выполняют запись/чтение комплексного числа из потока
(шаблон функции) [править]
выполняют потоковый вывод/ввод для std::bitset
(функция) [править]
выполняют потоковый вывод/ввод строк std::basic_string
(шаблон функции) [править]
выполняют потоковый вывод/ввод для объекта генератора псевдослучайных чисел
(функция) [править]

выполняют потоковый вывод/ввод для объекта распределения псевдослучайных чисел
(функция) [править]

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

Приоритет операций

Перегрузка операций

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

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)

Справка по CАрифметические операции