Arithmetic operators

특정 산술 연산의 결과를 반환합니다.

일반적인 설명

모든 내장 산술 연산자는 특정 산술 연산의 결과를 계산하고 그 결과를 반환합니다. 인수는 수정되지 않습니다.

변환

내장 산술 연산자에 전달된 피연산자가 정수형 또는 비범위 열거형인 경우, 다른 모든 동작 전에(그러나 적용 가능한 경우 lvalue-to-rvalue 변환 이후) 피연산자는 integral promotion 을 거칩니다. 피연산자가 배열 또는 함수 타입을 가지는 경우, array-to-pointer 및 function-to-pointer 변환이 적용됩니다.

이항 연산자(시프트 연산 제외)의 경우, 승격된 피연산자들의 타입이 서로 다르면 일반 산술 변환 이 적용됩니다.

오버플로우

부호 없는 정수 연산은 항상 modulo 2 n
으로 수행되며, 여기서 n은 해당 정수의 비트 수입니다. 예를 들어 unsigned int 의 경우, UINT_MAX 에 1을 더하면 ​ 0 ​ 이 되고, ​ 0 ​ 에서 1을 빼면 UINT_MAX 가 됩니다.

부호 있는 정수 산술 연산이 오버플로될 때(결과가 결과 타입에 맞지 않음), 그 동작은 정의되지 않습니다 — 이러한 연산의 가능한 현상으로는 다음이 포함됩니다:

• 이는 표현 방식의 규칙에 따라 감싸기(wrap around)됩니다 (일반적으로 two's complement ).
• 트랩(trap)됩니다 — 일부 플랫폼이나 컴파일러 옵션에 의해 (예: GCC와 Clang의 -ftrapv ).
• 최소값 또는 최대값으로 포화(saturate)됩니다 (많은 DSP에서).
• 컴파일러에 의해 완전히 optimized out by the compiler 됩니다.

부동소수점 환경

만약 #pragma STDC FENV_ACCESS 가 지원되고 ON 으로 설정된 경우, 모든 부동 소수점 연산자는 현재 부동 소수점 반올림 방향 을 따르며, math_errhandling 에 지정된 대로 부동 소수점 산술 오류를 보고합니다. 단, 정적 초기화 의 일부인 경우는 예외입니다(이 경우 부동 소수점 예외가 발생하지 않으며 반올림 모드는 가장 가까운 값으로 설정됩니다).

부동 소수점 축약

#pragma STDC FP_CONTRACT 가 지원되고 OFF 로 설정되지 않는 한, 모든 부동 소수점 연산은 중간 결과가 무한한 범위와 정밀도를 가진 것처럼 수행될 수 있습니다. 즉, 반올림 오류와 부동 소수점 예외를 생략하는 최적화가 허용됩니다. 예를 들어, C++은 ( x * y ) + z 를 단일 FMA(Fused Multiply-Add) CPU 명령어로 구현하거나 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"가 built-in type인 경우 단항 +는 no-op임
     // 부정 연산 수행 중에 가능한 모든 promotion이 이미 이루어지기 때문

내장 단항 산술 연산자

오버로드

사용자 정의 연산자에 대한 오버로드 해결 에서, 모든 cv-unqualified 승격된 산술 타입 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 모두 prvalue여야 하며, 다음 조건 중 하나를 만족해야 합니다:

• 두 피연산자 모두 산술 타입이나 비한정 열거형 타입을 가집니다. 이 경우, 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 가 null 포인터 값 으로 평가되고 J 가 ​ 0 ​ 으로 평가되면, 결과는 null 포인터 값입니다.
• 그렇지 않고 P 가 n 개의 요소를 가진 배열 객체 x 의 i 번째 요소를 가리키고, J 의 값이 j 로 주어지면, P 는 다음과 같이 더하거나 뺍니다:

• 표현식 P + J 과 J + P

• i+j 번째 요소를 가리키며, 이는 i + j 가 [ ​ 0 ​ , n ) 범위 내에 있을 경우에 해당합니다. 그리고
• i + j 가 n 인 경우, 마지막 요소의 끝을 지나는 포인터입니다.

• 표현식 P - J

• i-j 번째 요소를 가리키며, 이는 i - j 가 [ ​ 0 ​ , n ) 범위 내에 있을 경우에 해당합니다. 그리고
• i - j 가 n 인 경우, 마지막 요소의 끝을 지나는 포인터입니다.

• 다른 j 값들은 정의되지 않은 행동을 초래합니다.

• 그렇지 않고, P 가 완전한 객체, 기반 클래스 하위 객체 또는 멤버 하위 객체 y 를 가리키는 경우, J 의 값이 j 일 때, P 는 다음과 같이 더하거나 뺍니다:

• 표현식 P + J 과 J + P

• j 가 ​ 0 ​ 이면 y 를 가리키고,
• j 가 1 이면 y 의 끝을 지난 포인터입니다.

• 표현식 P - J

• j 가 ​ 0 ​ 이면 y 를 가리키고,
• j 가 - 1 이면 y 의 끝을 지난 포인터입니다.

• 다른 j 값들은 정의되지 않은 동작을 초래합니다.

• 그렇지 않고, P 가 객체 z 의 끝을 지난 포인터이고, J 의 값이 j 인 경우:

• 만약 z 가 n 개의 요소를 가진 배열 객체라면, P 는 다음과 같이 더하거나 뺍니다:

• 표현식 P + J 과 J + P

• n + j 가 [ ​ 0 ​ , n ) 범위 내에 있을 경우 z 의 n+j 번째 요소를 가리키고,
• j 가 ​ 0 ​ 일 경우 z 의 마지막 요소 바로 다음을 가리키는 포인터입니다.

• 표현식 P - J

• n - j 가 [ ​ 0 ​ , n ) 범위 내에 있을 경우 z 의 n-j 번째 요소를 가리키고,
• j 가 ​ 0 ​ 일 경우 z 의 마지막 요소 바로 다음을 가리키는 포인터입니다.

• 다른 j 값들은 정의되지 않은 행동을 초래합니다.

• 그렇지 않으면, P 는 다음과 같이 더하거나 뺍니다:

• 표현식 P + J 과 J + P

• j 가 - 1 일 경우 z 를 가리키고,
• j 가 ​ 0 ​ 일 경우 z 의 끝 바로 다음을 가리키는 포인터입니다.

• 표현식 P - J

• j 가 1 일 경우 z 를 가리키고,
• j 가 ​ 0 ​ 일 경우 z 의 끝 바로 다음을 가리키는 포인터입니다.

• 다른 j 값들은 정의되지 않은 행동을 초래합니다.

• 그 외의 경우, 동작은 정의되지 않습니다.

두 포인터 표현식 P 와 Q 를 뺄 때, 결과의 타입은 std::ptrdiff_t 입니다.

• 만약 P 와 Q 가 모두 널 포인터 값 으로 평가되면, 결과는 ​ 0 ​ 입니다.
• 그렇지 않고 P 와 Q 가 동일한 배열 객체 x 의 각각 i 번째와 j 번째 배열 요소를 가리키는 경우, 표현식 P - Q 의 값은 i − j 입니다.

• 만약 i − j 가 std::ptrdiff_t 로 표현 불가능할 경우, 동작은 정의되지 않습니다.

• 그렇지 않고, P 와 Q 가 동일한 완전 객체, 기본 클래스 하위 객체 또는 멤버 하위 객체를 가리키는 경우, 결과는 ​ 0 ​ 입니다.
• 그렇지 않은 경우, 동작은 정의되지 않습니다.

이러한 포인터 산술 연산자를 통해 포인터는 LegacyRandomAccessIterator 요구 사항을 충족할 수 있습니다.

덧셈과 뺄셈의 경우, P 또는 Q 가 "(cv 한정자가 있을 수 있는) T 에 대한 포인터" 타입을 가지고, T 와 배열 요소 타입이 유사(similar) 하지 않을 경우, 그 동작은 정의되지 않습니다:

int arr[5] = {1, 2, 3, 4, 5};
unsigned int *p = reinterpret_cast<unsigned int*>(arr + 1);
unsigned int k = *p; // 정상, "k"의 값은 2입니다
unsigned int *q = p + 1; // 정의되지 않은 동작: "p"는 unsigned int가 아닌 int를 가리킵니다

오버로드

사용자 정의 연산자에 대한 오버로드 해결 에서, 모든 승격된 산술 타입 쌍 L 과 R , 그리고 모든 객체 타입 T 에 대해 다음 함수 시그니처들이 오버로드 해결에 참여합니다:

여기서 LR 는 usual arithmetic conversions 가 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

비트 논리 연산자

비트 논리 연산자 표현식의 형식은 다음과 같습니다

비트 NOT 연산자는 모든 이항 산술 연산자보다 우선순위 가 더 높습니다. 오른쪽에서 왼쪽으로 결합합니다:

~a - b; // (~a) - b와 동일하며, ~(a - b)가 아님
~c * d; // (~c) * d와 동일하며, ~(c * d)가 아님
~-e; // ~(-e)와 동일함

~ 다음에 type name 또는 decltype specifier (since C++11) 이 올 때 문법적 모호성이 존재합니다: 이는 operator~일 수도 있고 destructor 식별자의 시작일 수도 있습니다. 이 모호성은 ~ 를 operator~로 해석함으로써 해결됩니다. ~ 는 operator~를 형성하는 것이 구문적으로 유효하지 않은 위치에서만 destructor 식별자를 시작할 수 있습니다.

다른 모든 비트 논리 연산자는 다른 모든 이항 산술 연산자보다 우선순위 가 낮습니다. 비트 AND는 비트 XOR보다 우선순위가 높으며, 비트 XOR은 비트 OR보다 우선순위가 높습니다. 이들은 왼쪽에서 오른쪽으로 결합합니다:

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 는 usual arithmetic conversions 가 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: " << mask << std::setw(49) << bin16(mask) << "\n"
                 "Value: " << x0 << std::setw(42) << bin32(x0) << "\n"
                 "Setting bits: " << x1 << std::setw(35) << bin32(x1) << "\n"
                 "Clearing bits: " << x2 << std::setw(34) << bin32(x2) << "\n"
                 "Selecting bits: " << x3 << std::setw(39) << bin32(x3) << "\n"
                 "XOR-ing bits: " << x4 << std::setw(35) << bin32(x4) << "\n"
                 "Inverting bits: " << x5 << std::setw(33) << bin32(x5) << '\n';
}

Mask: 0xf0                                 0000000011110000
Value: 0x12345678          00010010001101000101011001111000
Setting bits: 0x123456f8   00010010001101000101011011111000
Clearing bits: 0x12345608  00010010001101000101011000001000
Selecting bits: 0x70       00000000000000000000000001110000
XOR-ing bits: 0x12345688   00010010001101000101011010001000
Inverting bits: 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" // unsigned에서 오버플로우 발생
                 "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

표준 라이브러리

산술 연산자는 많은 표준 라이브러리 타입에 대해 오버로드됩니다.

단항 산술 연산자

덧셈 연산자

곱셈 연산자

비트 논리 연산자

비트 시프트 연산자

스트림 삽입/추출 연산자

표준 라이브러리 전체에서, 비트 시프트 연산자는 일반적으로 I/O 스트림( std:: ios_base & 또는 이를 상속받은 클래스들 중 하나)을 좌측 피연산자 및 반환 타입으로 오버로드됩니다. 이러한 연산자는 스트림 삽입 및 스트림 추출 연산자로 알려져 있습니다:

결함 보고서

다음의 동작 변경 결함 보고서들은 이전에 발표된 C++ 표준에 소급 적용되었습니다.

참고 항목

연산자 우선순위

연산자 오버로딩