std::compare_strong_order_fallback

inline namespace /* unspecified */ {
    inline constexpr /* unspecified */
        compare_strong_order_fallback = /* unspecified */;
}

template< class T, class U >
    requires /* see below */
constexpr std::strong_ordering
    compare_strong_order_fallback( T&& t, U&& u ) noexcept(/* see below */);

Realiza una comparación a tres vías en subexpresiones t y u y produce un resultado de tipo std::strong_ordering, incluso si el operador <=> no está disponible.

Si std::decay_t<T> y std::decay_t<U> son del mismo tipo, std::compare_strong_order_fallback(t, u) es equivalente a expresión a:

• std::strong_order(t, u), si es una expresión bien formada;
• en caso contrario, t == u ? std::strong_ordering::equal :
t < u ? std::strong_ordering::less :
         std::strong_ordering::greater

si las expresiones t == u y t < u son ambas bien formadas y cada una de decltype(t == u) y decltype(t < u) modela comprobable-booleano, excepto que t y u se evalúan solo una vez.

En todos los demás casos, std::compare_strong_order_fallback(t, u) está mal formado, lo que puede resultar en fallo de sustitución cuando aparece en el contexto inmediato de una instanciación de plantilla.

Objetos de punto de personalización

El nombre std::compare_strong_order_fallback denota un objeto de punto de personalización , que es un objeto función constante de un tipo de clase literal semiregular . Consulte CustomizationPointObject para más detalles.

Ejemplo

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también