Archivo de encabezado de la biblioteca estándar <compare>

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Archivos de encabezado de la biblioteca estándar

Apoyo del lenguaje <cfloat> <climits> <compare> (C++20) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)    <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) Conceptos <concepts> (C++20) Diagnósticos <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) Gestión de memoria <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) Metaprogramación <type_traits> (C++11) <ratio> (C++11)

Servicios generales <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) Contenedores <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <inplace_vector> (C++26)    <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> Iteradores <iterator> Rangos <generator> (C++23) <ranges> (C++20)

Algoritmos <algorithm> <numeric> Cadenas <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> Procesamiento de texto <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)    Numéricos <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <simd> (C++26) <valarray> Tiempo <chrono> (C++11) <ctime> Compatibilidad con C <ccomplex> (C++11/17/20*) <ciso646> (hasta C++20) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

Entrada/Salida <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) Apoyo para concurrencia <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) Apoyo de ejecución <execution> (C++17)

 

See More

Este archivo de encabezado es parte de la biblioteca de utilerías generales.

Conceptos

three_way_comparablethree_way_comparable_with (C++20)

Especifica que el operador <=> produce un resultado consistente en los tipos dados. (concepto)

Clases

partial_ordering (C++20)	El tipo del resultado de una comparación de tres vías que soporta todos los 6 operadores, no es sustituible y permite valores incomparables. (clase)
weak_ordering (C++20)	El tipo del resultado de una comparación de tres vías que soporta todos los 6 operadores y no es sustituible. (clase)
strong_ordering (C++20)	El tipo del resultado de una comparación de tres vías que soporta todos los 6 operadores y es sustituible. (clase)
common_comparison_category (C++20)	La categoría de comparación más fuerte a la que pueden convertirse todos los tipos dados. (plantilla de clase)
compare_three_way_result (C++20)	Obtiene el tipo del resultado del operador de comparación de tres vías <=> en tipos dados. (plantilla de clase)
compare_three_way (C++20)	Objeto función que implementa x <=> y (clase)

Objetos de punto de personalización

strong_order (C++20)	Realiza una comparación de tres vías y produce un resultado de tipo std::strong_ordering. (objeto punto de personalización)
weak_order (C++20)	Realiza una comparación de tres vías y produce un resultado de tipo std::weak_ordering. (objeto punto de personalización)
partial_order (C++20)	Realiza una comparación de tres vías y produce un resultado de tipo std::partial_ordering. (objeto punto de personalización)
compare_strong_order_fallback (C++20)	Realiza una comparación de tres vías y produce un resultado de tipo std::strong_ordering, incluso si operator<=> no se encuentra disponible. (objeto punto de personalización)
compare_weak_order_fallback (C++20)	Realiza una comparación de tres vías y produce un resultado de tipo std::weak_ordering, incluso si operator<=> no se encuentra disponible. (objeto punto de personalización)
compare_partial_order_fallback (C++20)	Realiza una comparación de tres vías y produce un resultado de tipo std::partial_ordering, incluso si operator<=> no se encuentra disponible. (objeto punto de personalización)

Funciones

is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)

Funciones de comparación nombradas. (función)

Sinopsis

namespace std {
  // tipos de categorías de comparación
  class partial_ordering;
  class weak_ordering;
  class strong_ordering;

  // funciones de comparación denominadas
  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; }

  // tipo de categoría de comparación común
  template<class... Ts>
  struct common_comparison_category {
    using type = /* véase descripción */;
  };
  template<class... Ts>
    using common_comparison_category_t = typename common_comparison_category<Ts...>::type;

  // concepto three_way_comparable
  template<class T, class Cat = partial_ordering>
    concept three_way_comparable = /* véase descripción */;
  template<class T, class U, class Cat = partial_ordering>
    concept three_way_comparable_with = /* véase descripción */;

  // resultado de la comparación de tres vías
  template<class T, class U = T> struct compare_three_way_result;

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

  // clase compare_three_way
  struct compare_three_way;

  // algoritmos de comparación
  inline namespace /* sin especificar */ {
    inline constexpr /* sin especificar */ strong_order = /* sin especificar */;
    inline constexpr /* sin especificar */ weak_order = /* sin especificar */;
    inline constexpr /* sin especificar */ partial_order = /* sin especificar */;
    inline constexpr /* sin especificar */ compare_strong_order_fallback = /* sin especificar */;
    inline constexpr /* sin especificar */ compare_weak_order_fallback = /* sin especificar */;
    inline constexpr /* sin especificar */ compare_partial_order_fallback = /* sin especificar */;
  }
}

Concepto three_way_comparable

namespace std {
  template<class T, class Cat>
    concept __ComparesAs =                // solo exposición
      same_as<common_comparison_category_t<T, Cat>, Cat>;

  template<class T, class U>
    concept __PartiallyOrderedWith =      // solo exposición
      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 =
      __WeaklyEqualityComparableWith<T, T> &&
      __PartiallyOrderedWith<T, T> &&
      requires(const remove_reference_t<T>& a, const remove_reference_t<T>& b) {
        { a <=> b } -> __ComparesAs<Cat>;
      };
}

Concepto three_way_comparable_with

namespace std {
  template<class T, class U, class Cat = partial_ordering>
    concept three_way_comparable_with =
      __WeaklyEqualityComparableWith<T, U> &&
      __PartiallyOrderedWith<T, U> &&
      three_way_comparable<T, Cat> &&
      three_way_comparable<U, Cat> &&
      common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
      three_way_comparable<
        common_reference_t<
          const remove_reference_t<T>&, const remove_reference_t<U>&>, Cat> &&
      requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) {
        { t <=> u } -> __ComparesAs<Cat>;
        { u <=> t } -> __ComparesAs<Cat>;
      };
}

Clase std::partial_ordering

namespace std {
  class partial_ordering {
    int value;          // solo exposición
    bool is_ordered;    // solo exposición

    // constructores solo para exposición
    constexpr explicit
      partial_ordering(eq v) noexcept :
        value(int(v)), is_ordered(true) {}      // solo exposición
    constexpr explicit
      partial_ordering(ord v) noexcept :
        value(int(v)), is_ordered(true) {}     // solo exposición
    constexpr explicit
      partial_ordering(ncmp v) noexcept :
        value(int(v)), is_ordered(false) {}   // solo exposición

  public:
    // valores válidos
    static const partial_ordering less;
    static const partial_ordering equivalent;
    static const partial_ordering greater;
    static const partial_ordering unordered;

    // comparaciones
    friend constexpr bool operator==(partial_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool
      operator==(partial_ordering v, partial_ordering w) noexcept = default;
    friend constexpr bool operator< (partial_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool operator> (partial_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool operator<=(partial_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool operator>=(partial_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool operator< (/* sin especificar */, partial_ordering v) noexcept;
    friend constexpr bool operator> (/* sin especificar */, partial_ordering v) noexcept;
    friend constexpr bool operator<=(/* sin especificar */, partial_ordering v) noexcept;
    friend constexpr bool operator>=(/* sin especificar */, partial_ordering v) noexcept;
    friend constexpr partial_ordering
      operator<=>(partial_ordering v, /* sin especificar */) noexcept;
    friend constexpr partial_ordering
      operator<=>(/* sin especificar */, partial_ordering v) noexcept;
  };

  // definiciones de los valores válidos
  inline constexpr partial_ordering partial_ordering::less(ord::less);
  inline constexpr partial_ordering partial_ordering::equivalent(eq::equivalent);
  inline constexpr partial_ordering partial_ordering::greater(ord::greater);
  inline constexpr partial_ordering partial_ordering::unordered(ncmp::unordered);
}

Clase std::weak_ordering

namespace std {
  class weak_ordering {
    int value;  // solo exposición

    // constructores solo para exposición
    constexpr explicit weak_ordering(eq v) noexcept : value(int(v)) {}  // solo exposición
    constexpr explicit weak_ordering(ord v) noexcept : value(int(v)) {} // solo exposición

  public:
    // valores válidos
    static const weak_ordering less;
    static const weak_ordering equivalent;
    static const weak_ordering greater;

    // conversiones
    constexpr operator partial_ordering() const noexcept;

    // comparaciones
    friend constexpr bool operator==(weak_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool operator==(weak_ordering v, weak_ordering w) noexcept = default;
    friend constexpr bool operator< (weak_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool operator> (weak_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool operator<=(weak_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool operator>=(weak_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool operator< (/* sin especificar */, weak_ordering v) noexcept;
    friend constexpr bool operator> (/* sin especificar */, weak_ordering v) noexcept;
    friend constexpr bool operator<=(/* sin especificar */, weak_ordering v) noexcept;
    friend constexpr bool operator>=(/* sin especificar */, weak_ordering v) noexcept;
    friend constexpr weak_ordering
      operator<=>(weak_ordering v, /* sin especificar */) noexcept;
    friend constexpr weak_ordering
      operator<=>(/* sin especificar */, weak_ordering v) noexcept;
  };

  // definiciones de los valores válidos
  inline constexpr weak_ordering weak_ordering::less(ord::less);
  inline constexpr weak_ordering weak_ordering::equivalent(eq::equivalent);
  inline constexpr weak_ordering weak_ordering::greater(ord::greater);
}

Clase std::strong_ordering

namespace std {
  class strong_ordering {
    int value;  // solo exposición

    // constructores solo para exposición
    constexpr explicit strong_ordering(eq v) noexcept :
      value(int(v)) {}    // solo exposición
    constexpr explicit strong_ordering(ord v) noexcept :
      value(int(v)) {}   // solo exposición

  public:
    // valores válidos
    static const strong_ordering less;
    static const strong_ordering equal;
    static const strong_ordering equivalent;
    static const strong_ordering greater;

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

    // comparaciones
    friend constexpr bool operator==(strong_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool
      operator==(strong_ordering v, strong_ordering w) noexcept = default;
    friend constexpr bool operator< (strong_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool operator> (strong_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool operator<=(strong_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool operator>=(strong_ordering v, /* sin especificar */) noexcept;
    friend constexpr bool operator< (/* sin especificar */, strong_ordering v) noexcept;
    friend constexpr bool operator> (/* sin especificar */, strong_ordering v) noexcept;
    friend constexpr bool operator<=(/* sin especificar */, strong_ordering v) noexcept;
    friend constexpr bool operator>=(/* sin especificar */, strong_ordering v) noexcept;
    friend constexpr strong_ordering
      operator<=>(strong_ordering v, /* sin especificar */) noexcept;
    friend constexpr strong_ordering
    operator<=>(/* sin especificar */, strong_ordering v) noexcept;
  };

  // definiciones de los valores válidos
  inline constexpr strong_ordering strong_ordering::less(ord::less);
  inline constexpr strong_ordering strong_ordering::equal(eq::equal);
  inline constexpr strong_ordering strong_ordering::equivalent(eq::equivalent);
  inline constexpr strong_ordering strong_ordering::greater(ord::greater);
}

Clase std::compare_three_way

namespace std {
  struct compare_three_way {
    template<class T, class U>
      requires three_way_comparable_with<T, U> || /*PTR-INTEGRADO-DE-TRES-VÍAS*/(T, U)
    constexpr auto operator()(T&& t, U&& u) const;

    using is_transparent = /* sin especificar */;
  };
}

Véase también

Documentación de C++ para Operador de comparación de tres vías (C++20)