std:: weak_order

Défini dans l'en-tête <compare>
inline namespace /* unspecified */ { inline constexpr /* unspecified */ weak_order = /* unspecified */ ; }		(depuis C++20)
Signature d'appel
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 la comparaison à trois voies et produit un résultat de type std::weak_ordering .

Soient t et u des expressions, et T et U désignent respectivement decltype ( ( t ) ) et decltype ( ( u ) ) , 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 de 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 par ordre faible des valeurs à virgule flottante (voir ci-dessous) et retourne ce résultat comme 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.

Table des matières 1 Objets de point de personnalisation 1.1 Ordre faible strict des types à virgule flottante IEEE 2 Exemple 3 Voir aussi

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

Cette section est incomplète Raison : aucun exemple

Voir aussi

weak_ordering (C++20)	le type de résultat de la comparaison à trois voies qui prend en charge les 6 opérateurs et n'est pas substituable (classe)
strong_order (C++20)	effectue une comparaison à trois voies et produit un résultat de type std::strong_ordering (objet de point de personnalisation)
partial_order (C++20)	effectue une comparaison à trois voies et produit un résultat de type std::partial_ordering (objet de point de personnalisation)
compare_weak_order_fallback (C++20)	effectue une comparaison à trois voies et produit un résultat de type std::weak_ordering , même si operator <=> n'est pas disponible (objet de point de personnalisation)