Namespaces
Variants

std:: nan, std:: nanf, std:: nanl

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)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Défini dans l'en-tête <cmath>
float nanf ( const char * arg ) ;
(1) (depuis C++11)
double nan ( const char * arg ) ;
(2) (depuis C++11)
long double nanl ( const char * arg ) ;
(3) (depuis C++11)

Convertit la chaîne de caractères arg en la valeur NaN silencieuse correspondante, comme en appelant std::strtof , std::strtod , ou std::strtold , respectivement.

1) L'appel std :: nanf ( " n-char-sequence ") , où n-char-sequence est une séquence de chiffres, de lettres ASCII et de tirets bas, est équivalent à l'appel std:: strtof ( "NAN( n-char-sequence ) " , ( char ** ) nullptr ) ; .
L'appel std :: nanf ( "" ) est équivalent à l'appel std:: strtof ( "NAN()" , ( char ** ) nullptr ) ; .
L'appel std :: nanf ( " string ") , où string n'est ni une n-char-sequence ni une chaîne vide, est équivalent à l'appel std:: strtof ( "NAN" , ( char ** ) nullptr ) ; .
2) Identique à (1) , mais appelle std::strtod au lieu de std::strtof .
3) Identique à (1) , mais appelle std::strtold au lieu de std::strtof .

Table des matières

Paramètres

arg - chaîne de caractères étroite identifiant le contenu d'un NaN

Valeur de retour

La valeur NaN silencieuse qui correspond à la chaîne d'identification arg ou zéro si l'implémentation ne prend pas en charge les NaN silencieux.

Si l'implémentation prend en charge l'arithmétique à virgule flottante IEEE (IEC 60559), elle prend également en charge les NaN silencieux.

Gestion des erreurs

Cette fonction n'est soumise à aucune des conditions d'erreur spécifiées dans math_errhandling .

Exemple

Exécuter ce code 
#include <cmath>
#include <cstdint>
#include <cstring>
#include <iostream>
int main()
{
    double f1 = std::nan("1");
    std::uint64_t f1n; std::memcpy(&f1n, &f1, sizeof f1);
    std::cout << "nan(\"1\") = " << f1 << " (" << std::hex << f1n << ")\n";
    double f2 = std::nan("2");
    std::uint64_t f2n; std::memcpy(&f2n, &f2, sizeof f2);
    std::cout << "nan(\"2\") = " << f2 << " (" << std::hex << f2n << ")\n";
}

Sortie possible : 

nan("1") = nan (7ff0000000000001)
nan("2") = nan (7ff0000000000002)

Voir aussi

(C++11)
vérifie si le nombre donné est NaN
(fonction)
(C++11)
évalue à un NaN silencieux de type float
(constante de macro)
[static]
identifie les types à virgule flottante qui peuvent représenter la valeur spéciale "not-a-number silencieux" (NaN)
(constante membre publique statique de std::numeric_limits<T> )
[static]
identifie les types à virgule flottante qui peuvent représenter la valeur spéciale "not-a-number signalé" (NaN)
(constante membre publique statique de std::numeric_limits<T> )
[static]
retourne une valeur NaN silencieux du type à virgule flottante donné
(fonction membre publique statique de std::numeric_limits<T> )
[static]
retourne une valeur NaN signalé du type à virgule flottante donné
(fonction membre publique statique de std::numeric_limits<T> )
Documentation C pour nanf , nan , nanl