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

Arithmetic 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)
Разное
Ассемблерные вставки
 
Возвращает результат конкретной операции арифметического.
Оригинал:
Returns the result of specific arithmetic operation.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Operator name Syntax Over​load​able Prototype examples (for class T)
Inside class definition Outside class definition
unary plus +a Да T T::operator+() const; T operator+(const T &a);
unary minus -a Да T T::operator-() const; T operator-(const T &a);
addition a + b Да T T::operator+(const T2 &b) const; T operator+(const T &a, const T2 &b);
subtraction a - b Да T T::operator-(const T2 &b) const; T operator-(const T &a, const T2 &b);
multiplication a * b Да T T::operator*(const T2 &b) const; T operator*(const T &a, const T2 &b);
division a / b Да T T::operator/(const T2 &b) const; T operator/(const T &a, const T2 &b);
modulo a % b Да T T::operator%(const T2 &b) const; T operator%(const T &a, const T2 &b);
bitwise NOT ~a Да T T::operator~() const; T operator~(const T &a);
bitwise AND a & b Да T T::operator&(const T2 &b) const; T operator&(const T &a, const T2 &b);
bitwise OR a | b Да T T::operator|(const T2 &b) const; T operator|(const T &a, const T2 &b);
bitwise XOR a ^ b Да T T::operator^(const T2 &b) const; T operator^(const T &a, const T2 &b);
bitwise left shift a << b Да T T::operator<<(const T2 &b) const; T operator<<(const T &a, const T2 &b);
bitwise right shift a >> b Да T T::operator>>(const T2 &b) const; T operator>>(const T &a, const T2 &b);
'Примечание'
Оригинал:
Notes
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Все встроенные значения операторов возвращения, и наиболее определяемый пользователем перегрузки также возвращать значения, так что пользовательские операторы могут быть использованы таким же образом, как и встроенные модули. Однако, в определенный пользователем оператор перегрузки, любого типа могут быть использованы в качестве возвращаемого типа (в том числе void). В частности, введение потока и потока добычи перегрузки operator<< и operator>> возвращения T&.
    Оригинал:
    All built-in operators return values, and most user-defined overloads also return values 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). In particular, stream insertion and stream extraction overloads of operator<< and operator>> return T&.
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • T2 может быть любого типа, включая T
    Оригинал:
    T2 can be any type including T
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

Содержание

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

Все арифметические операторы вычислить результат конкретной арифметической операции и возвращает его результат. Аргументы не изменяются.
Оригинал:
All arithmetic operators compute the result of specific arithmetic operation and returns its result. The arguments are not modified.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

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

Если операнд передается арифметической операции является неотъемлемой частью или незаданной типа перечисления, то перед любым другим действием (но после именующее к RValue преобразования, если это применимо), операнд подвергается интегрального продвижения по службе. Если операнд имеет массив или функцию типа массива в указатель и функции в указатель преобразования применяются.
Оригинал:
If the operand passed to an arithmetic operator is integral or unscoped enumeration type, then before any other action (but after lvalue-to-rvalue conversion, if applicable), the operand undergoes интегрального продвижения по службе. If an operand has array or function type, array-to-pointer and function-to-pointer conversions are applied.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Для бинарных операторов (кроме смены), если способствовал операндов разных типов, дополнительный набор неявных преобразований применяется, известный как обычные арифметические преобразования с целью получения общего типа' (также доступны через признака std::common_type типа)
Оригинал:
For the binary operators (except shifts), if the promoted operands have different types, additional set of implicit conversions is applied, known as usual arithmetic conversions with the goal to produce the common type (also accessible via the std::common_type type trait)
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Если один из операндов имеет тип перечисления областью, никакого преобразования не выполняется: другой операнд и возвращаемого типа должны иметь одинаковый тип
    Оригинал:
    If either operand has scoped enumeration type, no conversion is performed: the other operand and the return type must have the same type
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • В противном случае, если один из операндов long double, другой операнд преобразуется в long double
    Оригинал:
    Otherwise, if either operand is long double, the other operand is converted to long double
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • В противном случае, если один из операндов double, другой операнд преобразуется в double
    Оригинал:
    Otherwise, if either operand is double, the other operand is converted to double
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • В противном случае, если один из операндов float, другой операнд преобразуется в float
    Оригинал:
    Otherwise, if either operand is float, the other operand is converted to float
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • В противном случае, операнд имеет целый тип (потому что логический, символьный, char16_t, char32_t, wchar_t, и незаданной перечисления были повышены в этой точке) и интегральных преобразований применяется для получения общего типа, а именно:
    Оригинал:
    Otherwise, the operand has integer type (because bool, char, char16_t, char32_t, wchar_t, and unscoped enumeration were promoted at this point) and интегральных преобразований are applied to produce the common type, as follows:
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Если оба операнда будут подписаны или обе без знака, операнд с меньшим' преобразования ранга преобразуется в операнд с большим рангом преобразования целого числа
    Оригинал:
    If both operands are signed or both are unsigned, the operand with lesser conversion rank is converted to the operand with the greater integer conversion rank
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • В противном случае, если преобразование ранга без знака операнда больше или равна преобразования ранга подписан операнд, подписанного операнд преобразуется к типу без знака операнда.
    Оригинал:
    Otherwise, if the unsigned operand's conversion rank is greater or equal to the conversion rank of the signed operand, the signed operand is converted to the unsigned operand's type.
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • В противном случае, если подписанный тип операнда может представлять все значения без знака операнда, без знака операнд преобразуется к типу подписавшего операнда
    Оригинал:
    Otherwise, if the signed operand's type can represent all values of the unsigned operand, the unsigned operand is converted to the signer operand's type
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • В противном случае оба операнда преобразуется в беззнаковое коллегой типа подписано операнда.
    Оригинал:
    Otherwise, both operands are converted to the unsigned counterpart of the signed operand's type.
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Ранга' преобразования выше ростом порядка bool, signed char, short, int, long, long long. Ранг любой тип без знака равна рангу соответствующего подписанного типа. Звание char равна рангу signed char и unsigned char. В рядах char16_t, char32_t, и wchar_t равны ряды их основных типов.
Оригинал:
The conversion rank above increases in order bool, signed char, short, int, long, long long. The rank of any unsigned type is equal to the rank of the corresponding signed type. The rank of char is equal to the rank of signed char and unsigned char. The ranks of char16_t, char32_t, and wchar_t are equal to the ranks of their underlying types.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

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

Целое без знака арифметических всегда выполняется modulo 2n
где п-число битов в частности, что целое число. Например для unsigned int, добавив, один UINT_MAX дает 0, и вычитая одно из 0 дает UINT_MAX.
Оригинал:
Unsigned integer arithmetic is always performed modulo 2n
where n is the number of bits in that particular integer. E.g. for unsigned int, adding one to UINT_MAX gives 0, and subtracting one from 0 gives UINT_MAX.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Когда целое число арифметических операций переполнение (результат не помещается в результате тип), поведение не определено: это может обтекать в соответствии с правилами представления (как правило, дополнения 2), он может поймать на некоторых платформах или в связи с компилятором опции (например, -ftrapv в GCC и Clang), или может быть полностью optimized out by the compiler.
Оригинал:
When signed integer arithmetic operation overflows (the result does not fit in the result type), the behavior is undefined: it may wrap around according to the rules of the representation (typically 2's complement), it may trap on some platforms or due to compiler options (e.g. -ftrapv in GCC and Clang), or may be completely optimized out by the compiler.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

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

Для каждого способствовало A арифметического типа и для каждого типа T, следующие функции подписи участие в разрешении перегрузки
Оригинал:
For every promoted arithmetic type A and for every type T, the following function signatures participate in overload resolution:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
A operator+(A)
T* operator+(T*)
A operator-(A)
Унарный плюс встроенный оператор возвращает значение своего операнда. Единственная ситуация, когда это не является не-оп, когда операнд имеет интегрального типа или незаданной типа перечисления, которые изменились по интегральной продвижения, например, он преобразует char в int или, если операнд является предметом именующее к RValue, массива в указатель, или функции в указатель преобразования.
Оригинал:
The builtin unary plus operator returns the value of its operand. The only situation where it is not a no-op is when the operand has integral type or unscoped enumeration type, which is changed by integral promotion, e.g, it converts char to int or if the operand is subject to lvalue-to-rvalue, array-to-pointer, or function-to-pointer conversion.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Унарный минус встроенный оператор рассчитывает отрицательные своего операнда. Для беззнаковых a, значение -a является 2b
-a
, где b число битов после продвижения.
Оригинал:
The builtin unary minus operator calculates the negative of its operand. For unsigned a, the value of -a is 2b
-a
, where b is the number of bits after promotion.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
#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

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

Для каждой пары способствовали арифметические типы L и R и для каждого T тип объекта, следующие функции подписи участие в разрешении перегрузки
Оригинал:
For every pair of promoted arithmetic types L and R and for every object type T, the following function signatures participate in overload resolution:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
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
Оригинал:
where LR is the result of usual arithmetic conversions on L and R
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
С операндов арифметического или типа перечисления, в результате двоичный плюс сумма операндов (после обычных арифметических converesions), и результат бинарный минус оператора является результатом вычитания второго операнда из первого (после того, как обычные арифметические преобразования ).
Оригинал:
With operands of arithmetic or enumeration type, the result of binary plus is the sum of the operands (after usual arithmetic converesions), and the result of the binary minus operator is the result of subtracting the second operand from the first (after usual arithmetic conversions).
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Если любой из операндов является указателем, то применяются следующие правила:
Оригинал:
If any of the operands is a pointer, the following rules apply:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Указатель на не-объект массива рассматривается как указатель на первый элемент массива с размером 1.
    Оригинал:
    A pointer to non-array object is treated as a pointer to the first element of an array with size 1.
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Если указатель P указывает на ith элемент массива, то выражение P+n, n+P, и P-n являются указателями того же типа, что указывает на i+nth, i+nth, и i-nth элемент того же массива, соответственно. В результате указатель того также может быть одним пришедшего к концу указатель (то есть указатель P, что выражение P-1 указывает на последний элемент массива). Любые другие ситуации (то есть пытается создать указатель, который не указывает на элемент того же массива или за последним) вызывает неопределенное поведение.
    Оригинал:
    If the pointer P points to the ith element of an array, then the expressions P+n, n+P, and P-n are pointers of the same type that point to the i+nth, i+nth, and i-nth element of the same array, respectively. The result of pointer addition may also be a one-past-the-end pointer (that is, pointer P such that the expression P-1 points to the last element of the array). Any other situations (that is, attempts to generate a pointer that isn't pointing at an element of the same array or one past the end) invoke undefined behavior.
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Если указатель P указывает на ith элемент массива и указатель Q указывает на jth элемент того же массива, то выражение P-Q имеет значение i-j, если значение умещается в std::ptrdiff_t. Оба операнда должны указывают на элементы одного массива (или один в конце прошлого), в противном случае поведение не определено. Если результат не укладывается в std::ptrdiff_t, поведение не определено.
    Оригинал:
    If the pointer P points to the ith element of an array, and the pointer Q points at the jth element of the same array, the expression P-Q has the value i-j, if the value fits in std::ptrdiff_t. Both operands must point to the elements of the same array (or one past the end), otherwise the behavior is undefined. If the result does not fit in std::ptrdiff_t, the behavior is undefined.
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Если значение 0 добавляется или вычитается из указателя, то результатом является указатель, без изменений. Если два указателя точку на том же объекте или как одно прошлое конце того же массива, или оба нулевые указатели, то результат вычитания равен (std::ptrdiff_t)0.
    Оригинал:
    If the value 0 is added or subtracted from a pointer, the result is the pointer, unchanged. If two pointers point at the same object or are both one past the end of the same array, or both are null pointers, then the result of subtraction is equal to (std::ptrdiff_t)0.
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Эти операторы арифметики указателей позволяют указатели, чтобы удовлетворить RandomAccessIterator концепции.
Оригинал:
These pointer arithmetic operators allow pointers to satisfy the RandomAccessIterator concept.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
#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

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

Для каждой пары способствовали арифметические типы LA и RA и для каждой пары способствовали целых типов LI и RI следующие функции подписи участие в разрешении перегрузки
Оригинал:
For every pair of promoted arithmetic types LA and RA and for every pair of promoted integral types LI and RI the following function signatures participate in overload resolution:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
LRA operator*(LA, RA)
LRA operator/(LA, RA)
LRI operator%(LI, RI)
где LRx является результатом обычные арифметические преобразования на Lx и Rx
Оригинал:
where LRx is the result of usual arithmetic conversions on Lx and Rx
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
* Бинарный оператор выполняет умножение операндов (после обычные арифметические преобразования).
Оригинал:
The binary operator * performs multiplication of its operands (after usual arithmetic conversions).
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Бинарный оператор / делит первый операнд на второй (после обычные арифметические преобразования). Если второй операнд равен нулю, то поведение не определено. Для целых операндов, он дает алгебраическое фактор
Оригинал:
The binary operator / divides the first operand by the second (after usual arithmetic conversions).If the second operand is zero, the behavior is undefined. For integral operands, it yields the algebraic quotient
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • округлая в реализации определенного направления (до C++11)
    Оригинал:
    rounded in implementation-defined direction (до C++11)
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • с дробная часть отбрасывается (усеченный к нулю) (начиная с C++11)
    Оригинал:
    with any fractional part discarded (truncated towards zero) (начиная с C++11)
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
% Бинарный оператор дает остаток от деления первого операнда на второй (после обычные арифметические преобразования). Если фактор a/b является representible в результате типа, (a/b)*b + a%b == a. Если второй операнд равен нулю, то результат не определен.
Оригинал:
The binary operator % yields the remainder of the division of the first operand by the second (after usual arithmetic conversions). If the quotient a/b is representible in the result type, (a/b)*b + a%b == a. If the second operand is zero, the behavior is undefined.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Если один или оба операнда имеют отрицательный знак остальное зависит от реализации, так как она зависит от направления округления целых (до C++11) дивизии
    Оригинал:
    if one or both operands are negative, the sign of the remainder is implementation-defined, as it depends on the rounding direction of integer division (до C++11)
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
#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

[править] Операторы побитового логики

Для каждой пары способствовали целых типов L и R следующие функции подписи участие в разрешении перегрузки
Оригинал:
For every pair of promoted integral types L and R the following function signatures participate in overload resolution:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
R operator~(R)
LR operator&(L, R)
LR operator^(L, R)
LR operator|(L, R)
где LR является результатом обычные арифметические преобразования на L и R
Оригинал:
where LR is the result of usual arithmetic conversions on L and R
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
В результате оператор ~ является побитовое НЕ (дополнение до единицы) значения аргумента (после продвижения по службе). В результате оператор и является побитовое И значения операндов (после того, как обычные арифметические преобразования). В результате оператор
Оригинал:
является побитовое ИЛИ значения операндов (после того, как обычные арифметические преобразования). В результате оператор ^ является значение побитовое исключающее из операндов (после обычные арифметические преобразования)
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
#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

Вывод:

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

[править] Операторы побитового сдвига

Для каждой пары способствовали целых типов L и R, следующие функции подписи участие в разрешении перегрузки
Оригинал:
For every pair of promoted integral types L and R, the following function signatures participate in overload resolution:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
L operator<<(L, R)
L operator>>(L, R)
Операнды встроенные операторы побитового сдвига либо целочисленных типов или незаданной типа перечисления. Интегральная акции проводятся на оба операнда перед оценкой. Возвращаемый тип является типом левого операнда после integal акциях.
Оригинал:
The operands of the built-in bitwise shift operators have either integral types or unscoped enumeration type. Integral promotions are performed on both operands before evaluation. The return type is the type of the left operand after integal promotions.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Для беззнаковых a, значение a << b является значение a * 2b
, приведенные по модулю максимального значения возвращаемого типа плюс 1 (то есть, побитового сдвига влево выполняется, и биты, которые получают смещается из конечного типа отбрасываются). Для подписан a, значение a << b является a * 2b
, если она представима возвращаемого типа, в противном случае поведение не определено.
Оригинал:
For unsigned a, the value of a << b is the value of a * 2b
, reduced modulo maximum value of the return type plus 1 (that is, bitwise left shift is performed and the bits that get shifted out of the destination type are discarded). For signed a, the value of a << b is a * 2b
if it is representable by the return type, otherwise the behavior is undefined.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Для беззнаковых a и подписан a с неотрицательными значениями, значение a >> b является целой частью a/2b
. Для отрицательных a, значение a >> b определяется реализацией (в большинстве реализаций, это выполняет арифметические сдвиг вправо, так что результат остается отрицательным)
Оригинал:
For unsigned a and for signed a with nonnegative values, the value of a >> b is the integer part of a/2b
. For negative a, the value of a >> b is implementation-defined (in most implementations, this performs arithmetic right shift, so that the result remains negative)
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
В любом случае, если значение правого операнда является отрицательным или больше или равно количеству бит в способствовали левого операнда, результат не определен.
Оригинал:
In any case, if the value of the right operand is negative or is greater or equal to the number of bits in the promoted left operand, the behavior is undefined.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
#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

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

Арифметические операторы перегружены для многих стандартных типов библиотек.
Оригинал:
Arithmetic operators are overloaded for many standard library types.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

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

реализует унарные + и унарные -.
Оригинал:
implements unary + and unary -
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(public функция-член std::chrono::duration) [edit]
применяются унарные операторы для комплексных чисел
Оригинал:
applies unary operators to complex numbers
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(шаблон функции) [edit]
применяется унарный оператор арифметическое для каждого элемента valarray
Оригинал:
applies a unary arithmetic operator to each element of the valarray
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(public функция-член std::valarray) [edit]

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

изменяет момент времени в заданной длительности
Оригинал:
modifies the time point by the given duration
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(шаблон функции) [edit]
объединяет две строки или строку и символ
(шаблон функции) [edit]
перемещает итератор
Оригинал:
advances the iterator
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(public функция-член std::reverse_iterator)
Уменьшает итератор
Оригинал:
decrements the iterator
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(public функция-член std::reverse_iterator)
перемещает итератор
Оригинал:
advances the iterator
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(public функция-член std::move_iterator)
Уменьшает итератор
Оригинал:
decrements the iterator
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(public функция-член std::move_iterator)
выполняет сложную арифметику номер на двух комплексных значений или сложными и скаляр
Оригинал:
performs complex number arithmetics on two complex values or a complex and a scalar
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(шаблон функции) [edit]
применяется бинарных операторов для каждого элемента из двух valarrays, или valarray и значение
Оригинал:
applies binary operators to each element of two valarrays, or a valarray and a value
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(шаблон функции) [edit]

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

реализует арифметические операции с длительностью в качестве аргументов
Оригинал:
implements arithmetic operations with durations as arguments
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(шаблон функции) [edit]
выполняет сложную арифметику номер на двух комплексных значений или сложными и скаляр
Оригинал:
performs complex number arithmetics on two complex values or a complex and a scalar
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(шаблон функции) [edit]
применяется бинарных операторов для каждого элемента из двух valarrays, или valarray и значение
Оригинал:
applies binary operators to each element of two valarrays, or a valarray and a value
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(шаблон функции) [edit]

[править] Операторы побитового логики

выполняет двоичный AND, OR, XOR и NOT
Оригинал:
performs binary AND, OR, XOR and NOT
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(public функция-член std::bitset) [edit]
выполняет двоичной логики операций на bitsets
Оригинал:
performs binary logic operations on bitsets
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(функция) [edit]
применяется унарный оператор арифметическое для каждого элемента valarray
Оригинал:
applies a unary arithmetic operator to each element of the valarray
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(public функция-член std::valarray)
применяется бинарных операторов для каждого элемента из двух valarrays, или valarray и значение
Оригинал:
applies binary operators to each element of two valarrays, or a valarray and a value
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(шаблон функции)

[править] Операторы побитового сдвига

применяется бинарных операторов для каждого элемента из двух valarrays, или valarray и значение
Оригинал:
applies binary operators to each element of two valarrays, or a valarray and a value
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(шаблон функции)
выполняет двоичный сдвиг влево и сдвиг вправо
Оригинал:
performs binary shift left and shift right
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(public функция-член std::bitset)

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

На протяжении стандартные библиотеки, операторы побитового сдвига, как правило, перегружены поток ввода / вывода (std::ios_base& или одного из классов, производных от него) и как левый операнд и возвращает значение. Такие операторы, как известно, вставка поток' и' поток добычу операторов
Оригинал:
Throughout the standard library, bitwise shift operators are commonly overloaded with I/O stream (std::ios_base& or one of the classes derived from it) as both the left operand and return type. Such operators are known as stream insertion and stream extraction operators:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Экстракты отформатированные данные
Оригинал:
extracts formatted data
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(public функция-член std::basic_istream) [edit]
извлекает символов и массивов
Оригинал:
extracts characters and character arrays
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(шаблон функции) [edit]
вставками отформатированные данные
Оригинал:
inserts formatted data
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(public функция-член std::basic_ostream) [edit]
вставками символьных данных
Оригинал:
inserts character data
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(функция) [edit]
сериализации и десериализации комплексного числа
Оригинал:
serializes and deserializes a complex number
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(шаблон функции) [edit]
выполняет входной поток и выход bitsets
Оригинал:
performs stream input and output of bitsets
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(функция) [edit]
выполнение потоков ввода/вывода на строках
(шаблон функции) [edit]
осуществляет входной поток и выход на псевдослучайных чисел двигателя
Оригинал:
performs stream input and output on pseudo-random number engine
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(функция) [edit]
осуществляет входной поток и выход на псевдослучайных чисел распределения
Оригинал:
performs stream input and output on pseudo-random number distribution
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

(функция) [edit]

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

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

Common operators
назначение incrementNJdecrement арифметики логичной сравнение memberNJaccess другие

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
? :

Special operators
static_cast преобразует один тип на другой совместимый
типа
Оригинал:
static_cast converts one type to another compatible type
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
dynamic_cast преобразует виртуальный базовый класс для производных class
Оригинал:
dynamic_cast converts virtual base class to derived class
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
const_cast преобразует тип совместимого типа с различными cv qualifiers
Оригинал:
const_cast converts type to compatible type with different cv qualifiers
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
reinterpret_cast преобразует тип несовместимы type
Оригинал:
reinterpret_cast converts type to incompatible type
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
new выделяет memory
Оригинал:
new allocates memory
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
delete освобождает memory
Оригинал:
delete deallocates memory
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
sizeof запрашивает размер type
Оригинал:
sizeof queries the size of a type
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
sizeof... запрашивает размер Параметр пакета (начиная с C++11)
Оригинал:
sizeof... queries the size of a Параметр пакета (начиная с C++11)
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
typeid запрашивает сведения о типе type
Оригинал:
typeid queries the type information of a type
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
noexcept проверяет выражение может вызвать исключение (начиная с C++11)
Оригинал:
noexcept checks if an expression can throw an exception (начиная с C++11)
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
alignof запросов выравнивание требований типа (начиная с C++11)
Оригинал:
alignof queries alignment requirements of a type (начиная с C++11)
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.