std::strong_order

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

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

Compare deux valeurs à l'aide d'une comparaison à trois voies et produit un résultat de type std::strong_ordering.

Soient t et u des expressions et T et U désignant respectivement decltype((t)) et decltype((u)), std::strong_order(t, u) est équivalent à l'expression :

• Si std::is_same_v<std::decay_t<T>, std::decay_t<U>> est true :
  • std::strong_ordering(strong_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::strong_order,
  • sinon, si T est un type à virgule flottante :
    • si std::numeric_limits<T>::is_iec559 est true, effectue la comparaison ISO/IEC/IEEE 60559 totalOrder des valeurs à virgule flottante et retourne ce résultat sous forme d'une valeur de type std::strong_ordering (remarque : cette comparaison peut distinguer les zéros positifs et négatifs et les NaN avec des représentations différentes),
    • sinon, produit une valeur de type std::strong_ordering qui est cohérente avec l'ordre observé par les opérateurs de comparaison de T,
  • sinon, std::strong_ordering(std::compare_three_way()(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::strong_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 total strict des types à virgule flottante IEEE

Soient x et y des valeurs du même type à virgule flottante IEEE, et total_order_less ( x, y ) le résultat booléen indiquant si x précède y dans l'ordre total strict défini par totalOrder dans ISO/IEC/IEEE 60559.

( total_order_less ( x, y ) || total_order_less ( y, x ) ) == false si et seulement si x et y ont le même motif de bits.

• si ni x ni y n'est NaN :
  • si x < y , alors total_order_less ( x, y ) == true ;
  • si x > y , alors total_order_less ( x, y ) == false ;
  • si x == y ,
    • si x est zéro négatif et y est zéro positif, total_order_less ( x, y ) == true ,
    • si x n'est pas zéro et le champ d'exposant de x est inférieur à celui de y , alors total_order_less ( x, y ) == ( x > 0 ) (significatif uniquement pour les nombres flottants décimaux) ;
• si l'un des deux x ou y est NaN :
  • si x est NaN négatif et y n'est pas NaN négatif, alors total_order_less ( x, y ) == true ,
  • si x n'est pas NaN positif et y est NaN positif, alors total_order_less ( x, y ) == true ,
  • si x et y sont tous deux des NaNs avec le même signe et le champ de mantisse de x est inférieur à celui de y , alors total_order_less ( x, y ) == ! std:: signbit ( x ) .

Exemple

Voir aussi