Operatory arytmetyczne

Zwraca wynik określonej operacji arytmetycznej.

• 1 Objaśnienie
  • 1.1 Konwersje
  • 1.2 Przepełnienia
  • 1.3 Środowisko zmiennoprzecinkowe
  • 1.4 Skurcz zmiennoprzecinkowy
  • 1.5 Operatory arytmetyki jednoargumentowej
  • 1.6 Operatory addytywne
  • 1.7 Operatory multiplikatywne
  • 1.8 Bitowe operatory logiczne
  • 1.9 Operatory przesunięć bitowych
• 2 Biblioteka standardowa
  • 2.1 Operatory arytmetyki unarnej
  • 2.2 Operatory addytywne
  • 2.3 Operatory multiplikatywne
  • 2.4 Operatory logiczne bitowe
  • 2.5 Operatory przesunięć bitowych
  • 2.6 Operatory wstawiania/wyciągania strumienia
• 3 Raporty o wadach
• 4 Zobacz także

Objaśnienie

Wszystkie operatory arytmetyczne obliczają wynik określonej operacji arytmetycznej i zwracają jej wynik. Argumenty nie są modyfikowane.

Konwersje

Jeśli operand przekazany operatorowi arytmetycznemu jest typu integralnego lub nieskorelowanego typu wyliczeniowego, to przed jakimkolwiek innym działaniem (ale po konwersji z wartości na wartość, jeśli ma to zastosowanie) operand przechodzi promocję integralną. Jeśli operand ma typ tablicowy lub funkcyjny, stosowane są konwersje typu tablica na wskaźnik i funkcja na wskaźnik.

Dla operatorów binarnych (z wyjątkiem przesunięć), jeśli promowane operandy mają różne typy, stosowany jest dodatkowy zestaw niejawnych konwersji, znany jako zwykłe konwersje arytmetyczne, których celem jest wyprodukowanie wspólnego typu (dostępnego również przez cechę typu std::common_type). Jeśli, przed jakąkolwiek promocją integralną, jeden z operandów jest typu wyliczeniowego, a drugi operand jest typu zmiennoprzecinkowego lub innego typu wyliczeniowego, to zachowanie to jest zdeprecjonowane. (od C++20)

• Jeśli jeden z operandów ma typ wyliczeniowy, to konwersja nie jest wykonywana: drugi operand i typ zwracany muszą mieć ten sam typ

• W przeciwnym razie, jeśli którykolwiek z operandów jest long double, drugi operand jest konwertowany na long double

• W przeciwnym razie, jeśli którykolwiek z operandów jest double, drugi operand jest konwertowany na double

• W przeciwnym razie, Jeśli którykolwiek z operandów jest float, drugi operand jest konwertowany na float

• W przeciwnym razie operand ma typ integer (ponieważ bool, char, char8_t, char16_t, char32_t, wchar_t i unscoped enumeration zostały promowane w tym momencie) i integralne konwersji są stosowane do produkcji wspólnego typu, jak poniżej:

• Jeśli oba operandy są podpisane lub oba są niepodpisane, operand o mniejszym stopniu konwersji jest konwertowany na operand o większym stopniu konwersji liczby całkowitej

• W przeciwnym razie, jeśli stopień konwersji niepodpisanego operandu jest większy lub równy stopniowi konwersji podpisanego operandu, podpisany operand jest konwertowany na typ niepodpisanego operandu.

• W przeciwnym razie, jeśli typ podpisanego operandu może reprezentować wszystkie wartości niepodpisanego operandu, niepodpisany operand jest konwertowany na typ podpisanego operandu

• W przeciwnym razie oba operandy są konwertowane na niepodpisany odpowiednik typu podpisanego operandu.

Ranga konwersji powyżej wzrasta w kolejności bool, signed char, short, int, long, long long. Ranga każdego niepodpisanego typu jest równa randze odpowiadającego mu podpisanego typu. Ranga char jest równa randze podpisanego char i unsigned char. Rangi char8_t, char16_t, char32_t i wchar_t są równe rangom ich podstawowych typów.

Przepełnienia

Unsigned integer arithmetic jest zawsze wykonywany modulo 2n
gdzie n jest liczbą bitów w tej konkretnej liczbie całkowitej. Np. dla unsigned int, dodanie jedynki do UINT_MAX daje 0, a odjęcie jedynki od 0 daje UINT_MAX.

Gdy podpisana operacja arytmetyczna na liczbach całkowitych przepełnia się (wynik nie mieści się w typie wynikowym), zachowanie jest niezdefiniowane, – możliwe przejawy takiej operacji obejmują:

• owija się zgodnie z regułami reprezentacji (typowo 2’s complement),
• wpada w pułapkę – na niektórych platformach lub ze względu na opcje kompilatora (np.np. -ftrapv w GCC i Clang),
• nasyca się do wartości minimalnej lub maksymalnej (na wielu DSP),
• jest całkowicie zoptymalizowany przez kompilator.

Środowisko zmiennoprzecinkowe

Jeśli #pragma STDC FENV_ACCESS jest obsługiwana i ustawiona na ON, wszystkie operatory arytmetyki zmiennoprzecinkowej przestrzegają bieżącego kierunku zaokrąglania zmiennoprzecinkowego i zgłaszają błędy arytmetyki zmiennoprzecinkowej, jak określono w math_errhandling, chyba że są częścią inicjalizatora statycznego (w tym przypadku wyjątki zmiennoprzecinkowe nie są zgłaszane, a trybem zaokrąglania jest nearest)

Skurcz zmiennoprzecinkowy

Jeśli #pragma STDC FP_CONTRACT jest obsługiwana i ustawiona na OFF, cała arytmetyka zmiennoprzecinkowa może być wykonywana tak, jakby wyniki pośrednie miały nieskończony zakres i precyzję, to znaczy, dozwolone są optymalizacje, które pomijają błędy zaokrągleń i wyjątki zmiennoprzecinkowe. Na przykład, C++ pozwala na implementację (x*y) + z za pomocą pojedynczej instrukcji multiply-add CPU lub optymalizację a = x*x*x; jako tmp = x *x; a = tmp*tmp.

Niezwiązane z kontraktowaniem, pośrednie wyniki arytmetyki zmiennoprzecinkowej mogą mieć zakres i precyzję, która jest inna niż wskazana przez jej typ, zobacz FLT_EVAL_METHOD

Ogólnie, standard C++ nie gwarantuje dokładności operacji zmiennoprzecinkowych.

Operatory arytmetyczne jednoargumentowe

Wyrażenia operatorów arytmetycznych jednoargumentowych mają postać

Wbudowany operator unarny plus zwraca wartość swojego operandu. Jedyną sytuacją, gdy nie jest to no-op, jest gdy operand ma typ integralny lub typ wyliczeniowy, który jest zmieniany przez promocję integralną, np. konwertuje char na int lub gdy operand podlega konwersji lvalue-to-rvalue, array-to-pointer lub function-to-pointer.

Wbudowany jednoargumentowy operator minus oblicza minus swojego promowanego operandu. Dla unsigned a, wartością -a jest 2b
-a, gdzie b jest liczbą bitów po promocji.

W rozdzielczości przeciążania przeciwko operatorom zdefiniowanym przez użytkownika, dla każdego promowanego typu arytmetycznego A i dla każdego typu T, następujące sygnatury funkcji uczestniczą w rozdzielczości przeciążania:

#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; 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: 4294967295size of array: 3size of pointer: 8

#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 = {'a', 'b', 'c', 'd'}; char* p = &a; std::cout << "Pointer addition examples: " << *p << *(p + 2) << *(2 + p) << *(p - 1) << '\n'; char* p2 = &a; 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.12Pointer addition examples: bddaPointer difference: 3

#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 = -202 * (-10), where 2 is unsigned = 4294967276-10 / 2.12 = -4.71698-10 / 21 = 0-10 % 21 = -10

#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: 0xf0Setting bits: 0x123456f8Clearing bits: 0x12345608Selecting bits: 0x70

#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 = 0x2460x123 << 63 = 0x80000000000000000x10 << 10 = 0x4000-1000 >> 1 = -500