Namespaces
Variants

    operator==,!=,<,<=,>,>=,<=>(std::tuple)

    cppreference.net에서 가져옴
     
    C++
     
    유틸리티 라이브러리
    일반 유틸리티
    관계 연산자 (C++20에서 폐지됨)
    정수 비교 함수
    (C++20)(C++20)(C++20)    
    (C++20)
    교체 및 타입 연산swap
    exchange
    declval
    to_underlying
    forward
    forward_like
    move
    move_if_noexcept
    as_const
    공통 어휘 타입
    pair
    optional
    any
    variant
    tuple_size
    tuple_element
    apply
    make_from_tuple
    expected
    std::tuple



     
    멤버 함수
     
    에 정의됨 (1)<tuple> 
    template< class... TTypes, class... UTypes >
bool operator==( const std::tuple<TTypes...>& lhs,
                 const std::tuple<UTypes...>& rhs );
    		(C++11부터) (C++14부터 constexpr)
    (2)    		 
    template< class... TTypes, class... UTypes >
bool operator!=( const std::tuple<TTypes...>& lhs,
                 const std::tuple<UTypes...>& rhs );
    		(C++11부터) (C++14부터 constexpr)
    (C++20까지)
    (3)    		 
    template< class... TTypes, class... UTypes >
bool operator<( const std::tuple<TTypes...>& lhs,
                const std::tuple<UTypes...>& rhs );
    		(C++11부터) (C++14부터 constexpr)
    (C++20까지)
    (4)    		 
    template< class... TTypes, class... UTypes >
bool operator<=( const std::tuple<TTypes...>& lhs,
                 const std::tuple<UTypes...>& rhs );
    		(C++11부터) (C++14부터 constexpr)
    (C++20까지)
    (5)    		 
    template< class... TTypes, class... UTypes >
bool operator>( const std::tuple<TTypes...>& lhs,
                const std::tuple<UTypes...>& rhs );
    		(C++11부터) (C++14부터 constexpr)
    (C++20까지)
    (6)    		 
    template< class... TTypes, class... UTypes >
bool operator>=( const std::tuple<TTypes...>& lhs,
                 const std::tuple<UTypes...>& rhs );
    		(C++11부터) (C++14부터 constexpr)
    (C++20까지)
    (7) 
    template< class... TTypes, class... UTypes >
constexpr std::common_comparison_category_t<
    synth-three-way-result<TTypes, Elems>...>
    operator<=>( const std::tuple<TTypes...>& lhs,
                 const std::tuple<UTypes...>& rhs );
    		(C++20부터) (8) 
    template< class... TTypes, tuple-like UTuple >
constexpr bool operator==( const tuple<TTypes...>& lhs, const UTuple& rhs );
    		(C++23부터) (9) 
    template< class... TTypes, tuple-like UTuple >
constexpr std::common_comparison_category_t<
    synth-three-way-result<TTypes, /* Elems */>...>
    operator<=>( const tuple<TTypes...>& lhs, const UTuple& rhs );
    		(C++23부터) 1,2)
    튜플 의 각 요소를 튜플 lhs의 해당 요소와 rhs을 사용하여 비교합니다.operator==1)
    모든 대응 요소 쌍이 같으면 을 반환합니다.true2)
    을 반환합니다.!(lhs == rhs) 만약
    이 sizeof...(TTypes)과 같지 않거나, sizeof...(UTypes)이 std::get<i>(lhs) == std::get<i>(rhs)의 어떤 i에 대해서도 유효한 표현식이 아니라면, 프로그램의 형식이 잘못되었습니다(ill-formed).[0, sizeof...(Types))
    의 타입과 값 범주가 std::get<i>(lhs) == std::get<i>(rhs)의 어떤 에 대해서도 BooleanTestablei 요구 사항을 충족하지 않으면, 동작은 정의되지 않습니다.[0, sizeof...(Types))(C++26까지)
    		 이 오버로드는
    이 sizeof...(TTypes)과 같고, sizeof...(UTypes)가 유효한 표현식이며, std::get<i>(lhs) == std::get<i>(rhs)의 모든 decltype(std::get<i>(lhs) == std::get<i>(rhs))에 대해 boolean-testable을 모델링하는 경우에만 오버로드 해결에 참여합니다.i(C++26부터)[0, sizeof...(Types))3-6)
    과 을 lhs을 사용하여 사전식(lexicographically)으로 비교합니다. 즉, 첫 번째 요소를 비교하고, 동등하면 두 번째 요소를 비교하고, 그 요소들도 동등하면 세 번째 요소를 비교하는 식입니다.rhs3)operator< 빈 튜플에 대해서는
    을 반환합니다. 비어 있지 않은 튜플의 경우, 효과는 다음과 동등합니다.4)false
    if (std::get<0>(lhs) < std::get<0>(rhs)) return true; if (std::get<0>(rhs) < std::get<0>(lhs)) return false; if (std::get<1>(lhs) < std::get<1>(rhs)) return true; if (std::get<1>(rhs) < std::get<1>(lhs)) return false; ... return std::get<N - 1>(lhs) < std::get<N - 1>(rhs);
    을 반환합니다.5)!(rhs < lhs)
    을 반환합니다.6)rhs < lhs
    을 반환합니다. 만약 !(lhs < rhs)이
    과 같지 않거나, 동등 표현식(equivalent-to statements)에 표시된 비교 표현식 중 유효하지 않은 표현식이 있으면, 프로그램의 형식이 잘못되었습니다(ill-formed).sizeof...(TTypes) 동등 표현식에 표시된 비교 표현식 중 어떤 것의 타입과 값 범주가 sizeof...(UTypes)BooleanTestable
    요구 사항을 충족하지 않으면, 동작은 정의되지 않습니다.7)
    과 을 lhssynth-three-wayrhs를 사용하여 사전식으로 비교합니다. 즉, 첫 번째 요소를 비교하고, 동등하면 두 번째 요소를 비교하고, 그 요소들도 동등하면 세 번째 요소를 비교하는 식입니다. 빈 튜플의 경우 std::strong_ordering::equal

    if (auto c = synth-three-way(std::get<0>(lhs), std::get<0>(rhs)); c != 0) return c;
    if (auto c = 8)(std::get<1>(lhs), std::get<1>(rhs)); c != 0) return c;
    ...
    return  (std::get<N - 1>(lhs), std::get<N - 1>(rhs));

    (1)과 동일하지만, 이 객체이고, rhs의 요소 개수가 tuple-like 대신 rhs에 의해 결정된다는 점이 다릅니다. 이 오버로드는 std::tuple_size_v<UTuple>인자 종속 조회(argument-dependent lookup)를 통해서만 찾을 수 있습니다.9)
    (7)과 동일하지만, 이 rhs 객체라는 점이 다릅니다. tuple-like은 /* Elems */의 각 std::tuple_element_t<i, UTuple>에 대해 i을 나타내며, [0, std::tuple_size_v<UTuple>) 안에서 증가하는 순서입니다. 이 오버로드는 인자 종속 조회를 통해서만 찾을 수 있습니다.

    모든 비교 연산자는 단락 평가(short-circuited)됩니다. 즉, 비교 결과를 결정하는 데 필요한 요소 이상으로 튜플 요소에 접근하지 않습니다.

    <, <=, >, >=, 및 != 연산자는 각각 과 에서 operator<=>합성(synthesized)operator==됩니다.

    		(C++20부터)

    매개변수

    lhs, rhs - 비교할 튜플

    반환값

    1,8) true 를 반환합니다, 만약 std :: get < i > ( lhs ) == std :: get < i > ( rhs ) 가 [ ​ 0 ​ , sizeof... ( Types ) ) 범위의 모든 i 에 대해 참일 경우. 그렇지 않으면 false 를 반환합니다. 두 개의 빈 튜플에 대해서는 true 를 반환합니다.
    2) ! ( lhs == rhs )
    3) true 를 반환하는 경우는 lhs 에서 첫 번째로 동등하지 않은 요소가 rhs 의 해당 요소보다 작을 때이며, false 를 반환하는 경우는 rhs 에서 첫 번째로 동등하지 않은 요소가 lhs 의 해당 요소보다 작을 때이거나 동등하지 않은 요소가 존재하지 않을 때입니다. 두 개의 빈 튜플에 대해서는 false 를 반환합니다.
    4) ! ( rhs < lhs )
    5) rhs < lhs
    6) ! ( lhs < rhs )
    7,9) 첫 번째 쌍의 비동등 요소 간의 관계(존재하는 경우), 그렇지 않으면 std::strong_ordering::equal 을 반환합니다. 두 개의 빈 튜플에 대해서는 std::strong_ordering::equal 을 반환합니다.

    참고 사항

    관계 연산자는 각 요소의 operator < 를 기반으로 정의됩니다.

    		(C++20까지)

    관계 연산자는 synth-three-way 를 기반으로 정의되며, 이는 가능한 경우 operator <=> 를 사용하고, 그렇지 않으면 operator < 를 사용합니다.

    특히, 요소 타입 자체가 operator <=> 를 제공하지 않지만, three-way 비교 가능 타입으로 암시적으로 변환 가능한 경우, operator < 대신 해당 변환이 사용됩니다.

    		(C++20부터)
    기능 테스트 매크로 값 표준 기능
    __cpp_lib_constrained_equality 202403L (C++26) 제약된 operator == for std::tuple

    예제

    튜플에 대해 operator < 가 정의되어 있으므로, 튜플의 컨테이너를 정렬할 수 있습니다.

    이 코드 실행 
    #include <algorithm>
#include <iostream>
#include <tuple>
#include <vector>
int main()
{
    std::vector<std::tuple<int, std::string, float>> v
    {
        {2, "baz", -0.1},
        {2, "bar", 3.14},
        {1, "foo", 10.1},
        {2, "baz", -1.1},
    };
    std::sort(v.begin(), v.end());
    for (const auto& p: v)
        std::cout << "{ " << get<0>(p)
                  << ", " << get<1>(p)
                  << ", " << get<2>(p)
                  << " }\n";
}

    출력: 

    { 1, foo, 10.1 }
{ 2, bar, 3.14 }
{ 2, baz, -1.1 }
{ 2, baz, -0.1 }

    결함 보고서

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

    DR 적용 대상 게시된 동작 올바른 동작
    LWG 2114
    ( P2167R3 )     		C++11 불린 연산에 대한 타입 사전 조건이 누락됨 추가됨

    참고 항목

    (C++20에서 제거됨) (C++20에서 제거됨) (C++20에서 제거됨) (C++20에서 제거됨) (C++20에서 제거됨) (C++20)
    		pair 의 값을 사전식으로 비교합니다
    (함수 템플릿)