Dans les en- têtes stdint.h
(C99), boost / cstdint.hpp et cstdint
(C ++ 0x), il y a, entre autres, le type int32_t
.
Existe-t-il des types de virgule flottante de taille fixe similaires? Quelque chose comme float32_t
?
Dans les en- têtes stdint.h
(C99), boost / cstdint.hpp et cstdint
(C ++ 0x), il y a, entre autres, le type int32_t
.
Existe-t-il des types de virgule flottante de taille fixe similaires? Quelque chose comme float32_t
?
sizeof
opérateur. Un type comme celui-ci serait utile lorsqu'un algorithme exige qu'il s'agisse d'une taille spécifique connue.
sizeof
être utilisé pour résoudre le problème du rassemblement et de la suppression cohérents des types flottants?
Réponses:
Rien de tel n'existe actuellement dans les normes C ou C ++. En fait, il n'y a même pas de garantie que float
ce soit un format binaire à virgule flottante.
Certains compilateurs garantissent que le float
type sera le format binaire IEEE-754 32 bits. Certains non. En réalité, il float
s'agit en fait du type IEEE-754 single
sur la plupart des plates-formes non intégrées, bien que les mises en garde habituelles concernant certains compilateurs évaluant des expressions dans un format plus large s'appliquent.
Il existe un groupe de travail discutant de l'ajout de liaisons en langage C pour la révision 2008 de l'IEEE-754, qui pourrait envisager de recommander l'ajout d'un tel typedef. Si cela était ajouté à C, je m'attends à ce que le standard C ++ emboîte le pas ... éventuellement.
Si vous voulez savoir si vous êtes float
du type IEEE 32 bits, vérifiez std::numeric_limits<float>::is_iec559
. C'est une constante de compilation, pas une fonction.
Si vous voulez être plus à l'épreuve des balles, std::numeric_limits<float>::digits
assurez-vous également qu'ils n'utilisent pas sournoisement la double précision standard IEEE pour float
. Il devrait être 24.
En ce qui concerne long double
, il est plus important de vérifier digits
car il existe quelques formats IEEE qui pourraient raisonnablement être: 128 bits (chiffres = 113) ou 80 bits (chiffres = 64).
Ce ne serait pas pratique de l'avoir en float32_t
tant que tel car vous souhaitez généralement utiliser du matériel à virgule flottante, s'il est disponible, et ne pas recourir à une implémentation logicielle.
long double
format sur OS X (Intel 32 bits et 64 bits) est exactement le format double étendu IEEE-754 stocké dans l'ordre petit-boutiste. Rien de génial à ce sujet. Les octets 0 à 7 contiennent le champ significand et les octets 8 et 9 contiennent les champs exposant et signe.
5.0L
a un significand de a000000000000000
. Son exposant non biaisé est +2, et le double biais d'exposant étendu est 3fff
, donc l'exposant biaisé pour 5,0L est 4001
. Le modèle d'octet réel lorsqu'il est stocké dans l'ordre petit-boutiste est 00 00 00 00 00 00 00 a0 01 40
, et si vous le voyez comme deux entiers 64 bits petit-boutiste, vous verrez exactement ce que vous avez observé.
4001
little-endian est 01 40 00 00 ...
Si rien d'autre, l'octet le moins significatif vient en premier. Je m'attends à ce que la séquence a0 01 40
apparaisse quelque part dans le numéro (s'ils n'ont effectué qu'une rotation) mais je ne pense pas que vous ayez expliqué pourquoi a0
et que vous 01 40
soyez dans des moitiés complètement séparées.
Si vous pensez qu'avoir des typedefs tels que float32_t et float64_t n'est pas pratique pour quelque raison que ce soit, vous devez être trop habitué à votre système d'exploitation familier, compilateur, que vous ne pouvez pas trop regarder en dehors de votre petit nid.
Il existe du matériel qui exécute nativement des opérations en virgule flottante IEEE 32 bits et d'autres qui le font en 64 bits. Parfois, ces systèmes doivent même se parler, auquel cas il est extrêmement important de savoir si un double est 32 bits ou 64 bits sur chaque plate-forme. Si la plate-forme 32 bits devait effectuer des calculs excessifs sur la base des valeurs 64 bits de l'autre, nous souhaitons peut-être effectuer un cast à la précision inférieure en fonction des exigences de synchronisation et de vitesse.
Je me sens personnellement mal à l'aise d'utiliser des flotteurs et des doubles à moins de savoir exactement combien de bits ils se trouvent sur ma plate-forme. Encore plus si je dois les transférer sur une autre plate-forme via un canal de communication.
Il est actuellement proposé d'ajouter les types suivants dans la langue:
decimal32
decimal64
decimal128
qui peut un jour être accessible via #include <decimal>
.
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3871.html