Namespaces
Variants

std:: isunordered

From cppreference.net
C++
Numerics library
Common mathematical functions
Nearest integer floating point operations
(C++11)
(C++11)
(C++11) (C++11) (C++11)
Floating point manipulation functions
(C++11) (C++11)
(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
isunordered
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Défini dans l'en-tête <cmath>
(1)
bool isunordered ( float x, float y ) ;

bool isunordered ( double x, double y ) ;

bool isunordered ( long double x, long double y ) ;
(depuis C++11)
(jusqu'à C++23)
constexpr bool isunordered ( /* floating-point-type */ x,
/* floating-point-type */ y ) ;
(depuis C++23)
Défini dans l'en-tête <cmath>
template < class Arithmetic1, class Arithmetic2 >
bool isunordered ( Arithmetic1 x, Arithmetic2 y ) ;
(A) (depuis C++11)
(constexpr depuis C++23)
1) Détermine si les nombres à virgule flottante x et y ne sont pas ordonnés, c'est-à-dire qu'un ou les deux sont NaN et ne peuvent donc pas être comparés de manière significative l'un à l'autre. La bibliothèque fournit des surcharges pour tous les types à virgule flottante non qualifiés cv comme type des paramètres x et y . (depuis C++23)
A) Des surcharges supplémentaires sont fournies pour toutes les autres combinaisons de types arithmétiques.

Table des matières

Paramètres

x, y - valeurs à virgule flottante ou entières

Valeur de retour

true si soit x ou y est NaN, false sinon.

Notes

Les surcharges supplémentaires ne sont pas tenues d'être fournies exactement comme (A) . Elles doivent seulement être suffisantes pour garantir que pour leur premier argument num1 et second argument num2 :

  • Si num1 ou num2 a le type long double , alors std :: isunordered ( num1, num2 ) a le même effet que std :: isunordered ( static_cast < long double > ( num1 ) ,
    static_cast < long double > ( num2 ) )     .
  • Sinon, si num1 et/ou num2 a le type double ou un type entier, alors std :: isunordered ( num1, num2 ) a le même effet que std :: isunordered ( static_cast < double > ( num1 ) ,
    static_cast < double > ( num2 ) )     .
  • Sinon, si num1 ou num2 a le type float , alors std :: isunordered ( num1, num2 ) a le même effet que std :: isunordered ( static_cast < float > ( num1 ) ,
    static_cast < float > ( num2 ) )     .
(jusqu'en C++23)

Si num1 et num2 ont des types arithmétiques, alors std :: isunordered ( num1, num2 ) a le même effet que std :: isunordered ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ) , où /*common-floating-point-type*/ est le type à virgule flottante ayant le plus grand rang de conversion en virgule flottante et la plus grande sous-catégorie de conversion en virgule flottante entre les types de num1 et num2 , les arguments de type entier sont considérés comme ayant le même rang de conversion en virgule flottante que double .

Si aucun tel type à virgule flottante avec le plus grand rang et la plus grande sous-catégorie n'existe, alors la résolution de surcharge ne résulte pas en un candidat utilisable parmi les surcharges fournies.

(depuis C++23)

Exemple

Exécuter ce code 
#include <cmath>
#include <iostream>
#define SHOW_UNORDERED(x, y) \
    std::cout << std::boolalpha << "isunordered(" \
              << #x << ", " << #y << "): " \
              << std::isunordered(x, y) << '\n'
int main()
{
    SHOW_UNORDERED(10, 01);
    SHOW_UNORDERED(INFINITY, NAN);
    SHOW_UNORDERED(INFINITY, INFINITY);
    SHOW_UNORDERED(NAN, NAN);
}

Sortie : 

isunordered(10, 01): false
isunordered(INFINITY, NAN): true
isunordered(INFINITY, INFINITY): false
isunordered(NAN, NAN): true

Voir aussi

(C++11)
catégorise la valeur à virgule flottante donnée
(fonction)
(C++11)
vérifie si le nombre donné est NaN
(fonction)
Documentation C pour isunordered