std::weak_order

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

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

Compare deux valeurs en utilisant une comparaison à trois voies et produit un résultat de type std::weak_ordering.

Soient t et u des expressions et T et U désignant decltype((t)) et decltype((u)) respectivement. std::weak_order(t, u) est équivalent en expression à :

• Si std::is_same_v<std::decay_t<T>, std::decay_t<U>> est true :
  • std::weak_ordering(weak_order(t, u)), si c'est une expression bien formée avec une résolution de surcharge effectuée dans un contexte qui n'inclut pas une déclaration de std::weak_order.
  • Sinon, si T est un type à virgule flottante :
    • si std::numeric_limits<T>::is_iec559 est true, effectue la comparaison d'ordre faible des valeurs à virgule flottante (voir ci-dessous) et renvoie ce résultat sous forme d'une valeur de type std::weak_ordering.
    • Sinon, produit une valeur de type std::weak_ordering qui est cohérente avec l'ordre observé par les opérateurs de comparaison de T.
  • Sinon, std::weak_ordering(std::compare_three_way()(t, u)), si c'est bien formé,
  • Sinon, std::weak_ordering(std::strong_order(t, u)), si c'est bien formé.
• Dans tous les autres cas, l'expression est mal formée, ce qui peut entraîner un échec de substitution lorsqu'elle apparaît dans le contexte immédiat d'une instanciation de modèle.

Objets de point de personnalisation

Le nom std::weak_order désigne un objet de point de personnalisation , qui est un objet fonction constant d'un type de classe littéral semiregular . Voir CustomizationPointObject pour plus de détails.

Ordre faible strict des types à virgule flottante IEEE

Soient x et y des valeurs du même type à virgule flottante IEEE, et weak_order_less ( x, y ) le résultat booléen indiquant si x précède y dans l'ordre faible strict défini par la norme C++.

• Si ni x ni y n'est NaN, alors weak_order_less ( x, y ) == true si et seulement si x < y , c'est-à-dire que toutes les représentations d'une même valeur flottante sont équivalentes ;
• Si x est un NaN négatif et y n'est pas un NaN négatif, alors weak_order_less ( x, y ) == true ;
• Si x n'est pas un NaN positif et y est un NaN positif, alors weak_order_less ( x, y ) == true ;
• Si x et y sont tous deux des NaNs avec le même signe, alors ( weak_order_less ( x, y ) || weak_order_less ( y, x ) ) == false , c'est-à-dire que tous les NaNs avec le même signe sont équivalents.

Exemple

Voir aussi