Comparison operators

인수를 비교합니다.

양방향 비교

양방향 비교 연산자 표현식의 형식은 다음과 같습니다

관계 연산자

동등 연산자

내장 이중 비교 연산자

내장된 이항 비교 연산자의 경우, 좌측값에서 우측값으로의 변환 , 배열에서 포인터로의 변환 (C++26까지) 및 함수에서 포인터로의 변환 이 lhs 와 rhs 에 적용됩니다.

내장된 양방향 비교 연산자의 경우, 결과는 bool prvalue입니다.

내장 산술 비교

변환된 피연산자들이 모두 산술 타입이나 열거형 타입(범위 있는 또는 없는)을 가지는 경우, 일반 산술 변환 이 두 피연산자에 대해 수행됩니다. 값들은 변환 후에 비교됩니다:

#include <iostream>
int main()
{
    static_assert(sizeof(unsigned char) < sizeof(int),
                  "Cannot compare signed and smaller unsigned properly");
    int a = -1;
    int b = 1;
    unsigned int c = 1;
    unsigned char d = 1;
    std::cout << std::boolalpha
              << "두 개의 부호 있는 값 비교:\n"
                 " -1 == 1 ? " << (a == b) << "\n"
                 " -1 <  1 ? " << (a <  b) << "\n"
                 " -1 >  1 ? " << (a >  b) << "\n"
                 "부호 있는 값과 부호 없는 값 비교:\n"
                 // may issue different-signedness warning:
                 " -1 == 1 ? " << (a == c) << "\n"
                 // may issue different-signedness warning:
                 " -1 <  1 ? " << (a <  c) << "\n"
                 // may issue different-signedness warning:
                 " -1 >  1 ? " << (a >  c) << "\n"
                 "부호 있는 값과 더 작은 부호 없는 값 비교:\n"
                 " -1 == 1 ? " << (a == d) << "\n"
                 " -1 <  1 ? " << (a <  d) << "\n"
                 " -1 >  1 ? " << (a >  d) << '\n';
}

두 개의 부호 있는 값 비교:
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false
부호 있는 값과 부호 없는 값 비교:
 -1 == 1 ? false
 -1 <  1 ? false
 -1 >  1 ? true
부호 있는 값과 더 작은 부호 없는 값 비교:
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false

내장 포인터 동등 비교

동등 연산자 == 와 != 의 변환된 피연산자는 std::nullptr_t 타입, (C++11부터) 포인터 타입 또는 멤버 포인터 타입을 가질 수 있습니다.

내장 포인터 동등 비교에는 세 가지 가능한 결과가 있습니다: 동등, 비동등 및 지정되지 않음. 내장 포인터 동등 비교를 위한 동등 연산자가 생성하는 값은 아래와 같습니다:

변환된 lhs 와 rhs 중 적어도 하나가 포인터인 경우, 포인터 변환 , 함수 포인터 변환 (C++17부터) 과 한정 변환 이 양쪽 변환된 피연산자에 수행되어 복합 포인터 타입 으로 만듭니다. 복합 포인터 타입의 두 포인터는 다음과 같이 비교됩니다:

• 한 포인터가 완전한 객체의 주소를 나타내고 다른 포인터가

• 다른 완전한 비배열 객체의 끝을 지난 주소를 나타내거나,
• 다른 완전한 배열 객체의 마지막 요소를 지난 주소를 나타내는 경우,

비교 결과는 명시되지 않습니다.

• 그렇지 않고 두 포인터가 모두 null이거나, 둘 다 같은 함수를 가리키거나, 둘 다 같은 주소를 나타내는 경우(즉, 같은 객체를 가리키거나 객체의 끝을 지나는 경우), 두 포인터는 같다고 비교됩니다.
• 그렇지 않으면 포인터는 다르다고 비교됩니다.

변환된 lhs 와 rhs 중 적어도 하나가 멤버 포인터인 경우, 멤버 포인터 변환 , 함수 포인터 변환 (C++17부터) 과 한정 변환 이 두 변환된 피연산자에 수행되어 복합 포인터 타입 으로 만듭니다. 복합 포인터 타입의 두 멤버 포인터는 다음과 같이 비교됩니다:

• 두 멤버 포인터가 모두 널 멤버 포인터 값인 경우, 두 포인터는 같음으로 비교됩니다.
• 두 멤버 포인터 중 하나만 널 멤버 포인터 값인 경우, 두 포인터는 다름으로 비교됩니다.
• 둘 중 하나가 가상 멤버 함수 를 가리키는 경우, 결과는 지정되지 않습니다.
• 하나가 클래스 C1 의 멤버를 참조하고 다른 하나가 다른 클래스 C2 의 멤버를 참조하는 경우(둘 중 어느 것도 다른 클래스의 기본 클래스가 아닌 경우), 결과는 지정되지 않습니다.
• 둘 다 동일한 union 의 (서로 다른) 멤버를 참조하는 경우, 두 포인터는 같음으로 비교됩니다.
• 그렇지 않은 경우, 두 멤버 포인터는 연결된 클래스 타입의 가상 객체로 간접 참조를 수행할 경우 동일한 최종 파생 객체나 동일한 하위 객체의 동일한 멤버를 참조한다면 같음으로 비교되고, 그렇지 않으면 다름으로 비교됩니다.

struct P {};
struct Q : P { int x; };
struct R : P { int x; };
int P::*bx = (int(P::*)) &Q::x;
int P::*cx = (int(P::*)) &R::x;
bool b1 = (bx == cx); // 지정되지 않음
struct B
{
    int f();
};
struct L : B {};
struct R : B {};
struct D : L, R {};
int (B::*pb)() = &B::f;
int (L::*pl)() = pb;
int (R::*pr)() = pb;
int (D::*pdl)() = pl;
int (D::*pdr)() = pr;
bool x = (pdl == pdr); // false
bool y = (pb == pl);   // true

내장 포인터 관계 비교

관계 연산자 > , < , >= 및 <= 의 변환된 피연산자는 포인터 타입을 가질 수도 있습니다.

서로 다른 포인터에 대한 내장 포인터 관계 비교 p 와 q 는 세 가지 가능한 결과를 가집니다: p 가 더 큰 경우, q 가 더 큰 경우, 그리고 지정되지 않은 경우. 내장 포인터 관계 비교를 위한 관계 연산자가 반환하는 값은 아래에 나열되어 있습니다:

변환된 lhs 와 rhs 가 모두 포인터인 경우, 포인터 변환 , 함수 포인터 변환 (C++17부터) 및 한정 변환 이 두 변환된 피연산자에 수행되어 복합 포인터 타입 으로 변환됩니다. 복합 포인터 타입의 두 포인터는 다음과 같이 비교됩니다:

• 포인터들이 동일하게 비교되거나 동일성 비교 결과가 지정되지 않은 경우, 관계 비교 결과는 동일한 범주에 속합니다.
• 그렇지 않은 경우(포인터들이 서로 다르게 비교되는 경우), 포인터 중 하나라도 객체에 대한 포인터가 아니면 결과는 지정되지 않습니다.
• 그렇지 않은 경우(두 포인터 모두 객체를 가리키는 경우), 결과는 다음 규칙들과 일관된 부분 순서로 정의됩니다:

• 배열의 두 개의 서로 다른 원소 high 와 low 가 주어졌을 때, high 의 첨자가 low 의 첨자보다 높다면, 한 포인터가 high (또는 high 의 하위 객체)를 가리키고 다른 포인터가 low (또는 low 의 하위 객체)를 가리킬 때, 전자가 후자보다 비교 연산에서 더 크다고 판단됩니다.
• 한 포인터가 배열의 원소 elem (또는 elem 의 하위 객체)를 가리키고 다른 포인터가 동일한 배열의 끝을 넘어선 위치(past-the-end)를 가리킬 때, 끝을 넘어선 포인터가 다른 포인터보다 비교 연산에서 더 크다고 판단됩니다.
• 한 포인터가 완전한 객체, 기본 클래스 하위 객체 또는 멤버 하위 객체 obj (또는 obj 의 하위 객체)를 가리키고 다른 포인터가 obj 의 끝을 넘어선 위치를 가리킬 때, 끝을 넘어선 포인터가 다른 포인터보다 비교 연산에서 더 크다고 판단됩니다.

• 포인터들이 서로 다른 non-zero-sized (since C++20) non-static data members with the same member access (until C++23) 를 가리키거나, 비-union 클래스 타입의 동일한 객체 내에서 이러한 멤버들의 하위 객체들을 재귀적으로 가리킬 경우, 나중에 선언된 멤버를 가리키는 포인터가 다른 포인터보다 크게 비교됩니다.
• 그렇지 않은 경우, 결과는 지정되지 않습니다.

포인터 전체 순서

각 프로그램에는 구현에서 정의된 포인터에 대한 엄격한 전체 순서 가 존재합니다. 이 엄격한 전체 순서는 위에서 설명한 부분 순서와 일관됩니다: 지정되지 않은 결과는 구현에서 정의된 결과가 되며, 다른 결과는 동일하게 유지됩니다.

포인터 비교에 엄격한 전체 순서가 적용되는 경우는 다음과 같습니다:

• 포인터 타입 특수화의 operator ( ) 를 호출하는 std::less , std::greater , std::less_equal , 그리고 std::greater_equal .

오버로드

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

모든 객체 포인터 또는 함수 포인터 타입 P 에 대해, 다음 함수 시그니처들이 오버로드 해결에 참여합니다:

모든 멤버 객체 포인터 또는 멤버 함수 포인터인 타입 MP 에 대해 또는 std::nullptr_t (C++11부터) , 다음 함수 시그니처들이 오버로드 해결에 참여합니다:

#include <iostream>
struct Foo
{
    int n1;
    int n2;
};
union Union
{
    int n;
    double d;
};
int main()
{
    std::cout << std::boolalpha;
    char a[4] = "abc";
    char* p1 = &a[1];
    char* p2 = &a[2];
    std::cout << "Pointers to array elements:\n"
              << "p1 == p2? " << (p1 == p2) << '\n'
              << "p1 <  p2? " << (p1 <  p2) << '\n';
    Foo f;
    int* p3 = &f.n1;
    int* p4 = &f.n2;
    std::cout << "Pointers to members of a class:\n"
              << "p3 == p4? " << (p3 == p4) << '\n'
              << "p3 <  p4? " << (p3 <  p4) << '\n';
    Union u;
    int* p5 = &u.n;
    double* p6 = &u.d;
    std::cout << "Pointers to members of a union:\n"
              << "p5 == (void*)p6? " << (p5 == (void*)p6) << '\n'
              << "p5 <  (void*)p6? " << (p5 <  (void*)p6) << '\n';
}

Pointers to array elements:
p1 == p2? false
p1 <  p2? true
Pointers to members of a class:
p3 == p4? false
p3 <  p4? true
Pointers to members of a union:
p5 == (void*)p6? true
p5 <  (void*)p6? false

#include <compare>
#include <iostream>
int main()
{
    double foo = -0.0;
    double bar = 0.0;
    auto res = foo <=> bar;
    if (res < 0)
        std::cout << "-0 is less than 0";
    else if (res > 0)
        std::cout << "-0 is greater than 0";
    else if (res == 0)
        std::cout << "-0 and 0 are equal";
    else
        std::cout << "-0 and 0 are unordered";
}

-0 and 0 are equal

참고 사항

비교 연산자는 왼쪽에서 오른쪽으로 그룹화되므로, 표현식 a < b < c 는 ( a < b ) < c 로 파싱되며, a < ( b < c ) 또는 ( a < b ) && ( b < c ) 로 파싱되지 않습니다.

#include <iostream>
int main()
{
    int a = 3, b = 2, c = 1;
    std::cout << std::boolalpha
        << (a < b < c) << '\n' // true; 경고 발생 가능
        << ((a < b) < c) << '\n' // true
        << (a < (b < c)) << '\n' // false
        << ((a < b) && (b < c)) << '\n'; // false
}

사용자 정의 operator< 에 대한 일반적인 요구사항은 엄격한 약순서(strict weak ordering) 입니다. 특히, 이는 Compare 타입과 함께 동작하는 표준 알고리즘과 컨테이너들에 의해 요구됩니다: std::sort , std::max_element , std::map 등.

동일한 클래스의 서로 다른 비정적 데이터 멤버에 대한 포인터의 비교 결과 는 비정적 데이터 멤버들이 세 가지 멤버 접근 모드 각각에서 (C++23까지) 선언 순서대로 메모리에 배치됨을 의미합니다.

임의의 출처를 가진 포인터(예: 모두 동일한 배열의 멤버를 가리키지 않는 경우) 비교 결과는 명시되지 않았지만, 많은 구현체에서는 연속적인 가상 주소 공간 내의 주소로 구현된 경우와 같이 포인터의 엄격한 전체 순서 를 제공합니다. 이를 제공하지 않는 구현체(예: 포인터의 모든 비트가 메모리 주소의 일부가 아니어서 비교 시 무시해야 하거나 추가 계산이 필요하거나 포인터와 정수 간 1대1 관계가 아닌 경우)는 해당 보장을 갖는 포인터용 std::less 의 특수화를 제공합니다. 이를 통해 임의의 출처를 가진 모든 포인터를 std::set 이나 std::map 과 같은 표준 연관 컨테이너의 키로 사용할 수 있습니다.

EqualityComparable 와 LessThanComparable 요구 사항을 모두 만족하는 타입에 대해, C++ 표준 라이브러리는 동등성(equality) 와 등가성(equivalence) 를 구분합니다. 동등성 은 표현식 a == b 의 값이며, 등가성 은 표현식 ! ( a < b ) && ! ( b < a ) 의 값입니다.

포인터와 널 포인터 상수 간의 비교는 CWG issue 583 의 해결안이 N3624 에 포함되면서 제거되었습니다:

void f(char* p)
{
    if (p > 0) { /*...*/ } // N3624 이후 오류, N3624 이전에는 컴파일됨
    if (p > nullptr) { /*...*/ } // N3624 이후 오류, N3624 이전에는 컴파일됨
}
int main() {}

삼중 비교는 클래스 타입에 대해 자동으로 생성될 수 있습니다. 자세한 내용은 기본 비교 를 참조하십시오.

두 피연산자가 모두 배열인 경우, 삼중 비교는 형성되지 않습니다.

unsigned int i = 1;
auto r = -1 < i;    // 기존 함정: 'false'를 반환함
auto r2 = -1 <=> i; // 오류: 축소 변환이 필요함

표준 라이브러리

비교 연산자는 표준 라이브러리의 많은 클래스에 대해 오버로드됩니다.

네임스페이스 std::rel_ops 는 일반적인 연산자 ! = , > , <= , 그리고 >= 를 제공합니다:

결함 보고서

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

참고 항목

• 연산자 우선순위
• 연산자 오버로딩
• Compare (명명된 요구 사항)