Namespaces
Variants

std:: strong_order

From cppreference.net
C++
Utilities library
Défini dans l'en-tête <compare>
inline namespace /* unspecified */ {

inline constexpr /* unspecified */ strong_order = /* unspecified */ ;

}
(depuis C++20)
Signature d'appel
template < class T, class U >

requires /* voir ci-dessous */

constexpr std:: strong_ordering strong_order ( T && t, U && u ) noexcept ( /* voir ci-dessous */ ) ;

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

Soient t et u des expressions, et T et U désignent decltype ( ( t ) ) et decltype ( ( u ) ) respectivement, std :: strong_order ( t, u ) est équivalent en 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 de 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 totalOrder ISO/IEC/IEEE 60559 des valeurs à virgule flottante et retourne ce résultat comme une valeur de type std::strong_ordering (note : cette comparaison peut distinguer entre le zéro positif et négatif et entre les NaN avec différentes représentations),
      • 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 une échec de substitution lorsqu'elle apparaît dans le contexte immédiat d'une instanciation de template.

Table des matières

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

Cette section est incomplète
Raison : aucun exemple

Voir aussi

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