Standard library header <compare> (C++20)

From ko.cppreference.net

이 헤더는 언어 지원 라이브러리의 일부입니다.

목차 1 개념 2 클래스 3 커스터마이제이션 포인트 객체 4 함수 5 개요 5.1 개념 three_way_comparable 5.2 개념 three_way_comparable_with 5.3 클래스 std::partial_ordering 5.4 클래스 std::weak_ordering 5.5 클래스 std::strong_ordering 5.6 클래스 std::compare_three_way 5.7 클래스 std::type_order 6 참고 항목 개념(Concepts)
three_way_comparable three_way_comparable_with (C++20)	주어진 타입들에 대해 <=> 연산자가 일관된 결과를 생성함을 명시 (concept)
클래스
partial_ordering (C++20)	6개의 연산자를 모두 지원하고, 치환 가능하지 않으며, 비교 불가능한 값을 허용하는 3-way 비교의 결과 타입 (class)
weak_ordering (C++20)	6개의 연산자를 모두 지원하고 대체 가능하지 않은 3-way 비교의 결과 타입 (클래스)
strong_ordering (C++20)	6개의 연산자를 모두 지원하고 대체 가능한 3-way 비교의 결과 타입 (클래스)
common_comparison_category (C++20)	주어진 모든 타입이 변환될 수 있는 가장 강력한 비교 범주 (클래스 템플릿)
compare_three_way_result (C++20)	주어진 타입들에 대한 삼중 비교 연산자 <=> 의 결과 타입을 구함 (클래스 템플릿)
compare_three_way (C++20)	x <=> y 를 구현하는 제약된 함수 객체 (클래스)
커스터마이제이션 포인트 객체
strong_order (C++20)	3-way 비교를 수행하고 `std::strong_ordering` 타입의 결과를 생성함 (커스터마이제이션 포인트 객체)
weak_order (C++20)	3-way 비교를 수행하고 `std::weak_ordering` 타입의 결과를 생성함 (커스터마이제이션 포인트 객체)
partial_order (C++20)	3방향 비교를 수행하고 `std::partial_ordering` 타입의 결과를 생성합니다 (커스터마이제이션 포인트 객체)
compare_strong_order_fallback (C++20)	3방향 비교를 수행하고 `std::strong_ordering` 타입의 결과를 생성하며, operator <=> 를 사용할 수 없는 경우에도 작동합니다 (커스터마이제이션 포인트 객체)
compare_weak_order_fallback (C++20)	3방향 비교를 수행하고 `std::weak_ordering` 타입의 결과를 생성합니다. operator <=> 를 사용할 수 없는 경우에도 동작합니다 (커스터마이제이션 포인트 객체)
compare_partial_order_fallback (C++20)	3방향 비교를 수행하고 `std::partial_ordering` 타입의 결과를 생성합니다. operator <=> 가 사용 불가능한 경우에도 동작합니다 (커스터마이제이션 포인트 객체)
함수
is_eq is_neq is_lt is_lteq is_gt is_gteq (C++20)	명명된 비교 함수 (함수)

개요

// all freestanding
namespace std {
  // comparison category types
  class partial_ordering;
  class weak_ordering;
  class strong_ordering;

  // named comparison functions
  constexpr bool is_eq(partial_ordering cmp) noexcept { return cmp == 0; }
  constexpr bool is_neq(partial_ordering cmp) noexcept { return cmp != 0; }
  constexpr bool is_lt(partial_ordering cmp) noexcept { return cmp < 0; }
  constexpr bool is_lteq(partial_ordering cmp) noexcept { return cmp <= 0; }
  constexpr bool is_gt(partial_ordering cmp) noexcept { return cmp > 0; }
  constexpr bool is_gteq(partial_ordering cmp) noexcept { return cmp >= 0; }

  // common comparison category type
  template<class... Ts> struct common_comparison_category
  {
    using type = /* see description */;
  };
  template<class... Ts>
  using common_comparison_category_t = common_comparison_category<Ts...>::type;

  // concept three_way_comparable
  template<class T, class Cat = partial_ordering>
  concept three_way_comparable = /* see description */;
  template<class T, class U, class Cat = partial_ordering>
  concept three_way_comparable_with = /* see description */;

  // result of three-way comparison
  template<class T, class U = T> struct compare_three_way_result;

  template<class T, class U = T>
  using compare_three_way_result_t = compare_three_way_result<T, U>::type;

  // class compare_three_way
  struct compare_three_way;

  // comparison algorithms
  inline namespace /* unspecified */ {
    inline constexpr /* unspecified */ strong_order = /* unspecified */;
    inline constexpr /* unspecified */ weak_order = /* unspecified */;
    inline constexpr /* unspecified */ partial_order = /* unspecified */;
    inline constexpr /* unspecified */ compare_strong_order_fallback = /* unspecified */;
    inline constexpr /* unspecified */ compare_weak_order_fallback = /* unspecified */;
    inline constexpr /* unspecified */ compare_partial_order_fallback = /* unspecified */;
  }

  // type ordering
  template<class T, class U> struct type_order;

  template<class T, class U>
  constexpr strong_ordering type_order_v = type_order<T, U>::value;
}

개념 `three_way_comparable`

namespace std {
template<class T, class Cat>
concept /*compares-as*/ =            // exposition-only
  same_as<common_comparison_category_t<T, Cat>, Cat>;

template<class T, class U>
concept /*partially-ordered-with*/ = // exposition-only
  requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) {
    { t < u  } -> /*boolean-testable*/;
    { t > u  } -> /*boolean-testable*/;
    { t <= u } -> /*boolean-testable*/;
    { t >= u } -> /*boolean-testable*/;
    { u < t  } -> /*boolean-testable*/;
    { u > t  } -> /*boolean-testable*/;
    { u <= t } -> /*boolean-testable*/;
    { u >= t } -> /*boolean-testable*/;
  };

template<class T, class Cat = partial_ordering>
concept three_way_comparable =
  /*weakly-equality-comparable-with*/<T, T> && /*partially-ordered-with*/<T, T> &&
  requires(const remove_reference_t<T>& a, const remove_reference_t<T>& b) {
    { a <=> b } -> /*compares-as*/<Cat>;
  };
}

개념 `three_way_comparable_with`

namespace std {
template<class T, class U, class Cat = partial_ordering>
concept three_way_comparable_with =
  three_way_comparable<T, Cat> && three_way_comparable<U, Cat> &&
  /*comparison-common-type-with*/<T, U> &&
  three_way_comparable<
    common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>,
    Cat> &&
  /*weakly-equality-comparable-with*/<T, U> && /*partially-ordered-with*/<T, U> &&
  requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) {
    { t <=> u } -> /*compares-as*/<Cat>;
    { u <=> t } -> /*compares-as*/<Cat>;
  };
}

클래스 `std::partial_ordering`

namespace std {
  class partial_ordering
  {
    int /*value*/;       // exposition-only
    bool /*is-ordered*/; // exposition-only

    // exposition-only constructors
    constexpr explicit partial_ordering(/*ord*/ v) noexcept
      : /*value*/(int(v))
      , /*is-ordered*/(true)
    {
    } // exposition-only
    constexpr explicit partial_ordering(/*ncmp*/ v) noexcept
      : /*value*/(int(v))
      , /*is-ordered*/(false)
    {
    } // exposition-only

  public:
    // valid values
    static const partial_ordering less;
    static const partial_ordering equivalent;
    static const partial_ordering greater;
    static const partial_ordering unordered;

    // comparisons
    friend constexpr bool operator==(partial_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator==(partial_ordering v,
                                     partial_ordering w) noexcept = default;
    friend constexpr bool operator<(partial_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator>(partial_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator<=(partial_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator>=(partial_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator<(/* unspecified */, partial_ordering v) noexcept;
    friend constexpr bool operator>(/* unspecified */, partial_ordering v) noexcept;
    friend constexpr bool operator<=(/* unspecified */, partial_ordering v) noexcept;
    friend constexpr bool operator>=(/* unspecified */, partial_ordering v) noexcept;
    friend constexpr partial_ordering operator<=>(partial_ordering v,
                                                  /* unspecified */) noexcept;
    friend constexpr partial_ordering operator<=>(/* unspecified */,
                                                  partial_ordering v) noexcept;
  };

  // valid values' definitions
  inline constexpr partial_ordering partial_ordering::less(/*ord*/::/*less*/);
  inline constexpr partial_ordering partial_ordering::equivalent(/*ord*/::/*equivalent*/);
  inline constexpr partial_ordering partial_ordering::greater(/*ord*/::/*greater*/);
  inline constexpr partial_ordering partial_ordering::unordered(/*ncmp*/::/*unordered*/);
}

클래스 `std::weak_ordering`

namespace std {
  class weak_ordering
  {
    int /*value*/; // exposition-only

    // exposition-only constructors
    constexpr explicit weak_ordering(/*ord*/ v) noexcept
      : /*value*/(int(v))
    {
    } // exposition-only

  public:
    // valid values
    static const weak_ordering less;
    static const weak_ordering equivalent;
    static const weak_ordering greater;

    // conversions
    constexpr operator partial_ordering() const noexcept;

    // comparisons
    friend constexpr bool operator==(weak_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator==(weak_ordering v, weak_ordering w) noexcept = default;
    friend constexpr bool operator<(weak_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator>(weak_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator<=(weak_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator>=(weak_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator<(/* unspecified */, weak_ordering v) noexcept;
    friend constexpr bool operator>(/* unspecified */, weak_ordering v) noexcept;
    friend constexpr bool operator<=(/* unspecified */, weak_ordering v) noexcept;
    friend constexpr bool operator>=(/* unspecified */, weak_ordering v) noexcept;
    friend constexpr weak_ordering operator<=>(weak_ordering v,
                                               /* unspecified */) noexcept;
    friend constexpr weak_ordering operator<=>(/* unspecified */,
                                               weak_ordering v) noexcept;
  };

  // valid values' definitions
  inline constexpr weak_ordering weak_ordering::less(/*ord*/::/*less*/);
  inline constexpr weak_ordering weak_ordering::equivalent(/*ord*/::/*equivalent*/);
  inline constexpr weak_ordering weak_ordering::greater(/*ord*/::/*greater*/);
}

클래스 `std::strong_ordering`

namespace std {
  class strong_ordering
  {
    int /*value*/; // exposition-only

    // exposition-only constructors
    constexpr explicit strong_ordering(/*ord*/ v) noexcept
      : /*value*/(int(v))
    {
    } // exposition-only

  public:
    // valid values
    static const strong_ordering less;
    static const strong_ordering equal;
    static const strong_ordering equivalent;
    static const strong_ordering greater;

    // conversions
    constexpr operator partial_ordering() const noexcept;
    constexpr operator weak_ordering() const noexcept;

    // comparisons
    friend constexpr bool operator==(strong_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator==(strong_ordering v,
                                     strong_ordering w) noexcept = default;
    friend constexpr bool operator<(strong_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator>(strong_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator<=(strong_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator>=(strong_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator<(/* unspecified */, strong_ordering v) noexcept;
    friend constexpr bool operator>(/* unspecified */, strong_ordering v) noexcept;
    friend constexpr bool operator<=(/* unspecified */, strong_ordering v) noexcept;
    friend constexpr bool operator>=(/* unspecified */, strong_ordering v) noexcept;
    friend constexpr strong_ordering operator<=>(strong_ordering v,
                                                 /* unspecified */) noexcept;
    friend constexpr strong_ordering operator<=>(/* unspecified */,
                                                 strong_ordering v) noexcept;
  };

  // valid values' definitions
  inline constexpr strong_ordering strong_ordering::less(/*ord*/::/*less*/);
  inline constexpr strong_ordering strong_ordering::equal(/*ord*/::/*equal*/);
  inline constexpr strong_ordering strong_ordering::equivalent(/*ord*/::/*equivalent*/);
  inline constexpr strong_ordering strong_ordering::greater(/*ord*/::/*greater*/);
}

클래스 std:: compare_three_way

namespace std {
  struct compare_three_way {
    template<class T, class U>
    constexpr auto operator()(T&& t, U&& u) const;
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 `std::type_order`

namespace std {
  template<class T, class U> struct type_order {
    static constexpr strong_ordering value = /*TYPE-ORDER*/(T, U);
    
    using value_type = strong_ordering;
    
    constexpr operator value_type() const noexcept { return value; }
    constexpr value_type operator()() const noexcept { return value; }
  };
}

참고 항목

3-way 비교 연산자 표현식 lhs

<=>

rhs (C++20)

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

ko.cppreference.net

Namespaces

Variants

Standard library header <compare> (C++20)

목차

개념(Concepts)

클래스

커스터마이제이션 포인트 객체

함수

개요

개념 `three_way_comparable`

개념 `three_way_comparable_with`

클래스 `std::partial_ordering`

클래스 `std::weak_ordering`

클래스 `std::strong_ordering`

클래스 std:: compare_three_way

클래스 `std::type_order`

참고 항목

ko.cppreference.net

Namespaces

Variants

Standard library header <compare> (C++20)

목차

개념(Concepts)

클래스

커스터마이제이션 포인트 객체

함수

개요

개념 three_way_comparable

개념 three_way_comparable_with

클래스 std::partial_ordering

클래스 std::weak_ordering

클래스 std::strong_ordering

클래스 std:: compare_three_way

클래스 std::type_order

참고 항목

개념 `three_way_comparable`

개념 `three_way_comparable_with`

클래스 `std::partial_ordering`

클래스 `std::weak_ordering`

클래스 `std::strong_ordering`

클래스 `std::type_order`