Taille de int et float

J’ai une question sur les gammes d’ints et de flotteurs:

S’ils ont tous les deux la même taille de 4 octets, pourquoi ont-ils des plages différentes?

Ils sont totalement différents – en général, int est simplement un entier simple signé avec complément à 2, tandis que float est une représentation en virgule flottante simple précision avec 23 bits de mantisse, un exposant de 8 bits et un signe de 1 bit (voir http://en.wikipedia.org/ wiki / IEEE_754-2008 ).

Ils ont des plages de valeurs différentes car leur contenu est interprété différemment; autrement dit, ils ont des représentations différentes.

Les flotteurs et les doubles sont généralement représentés comme quelque chose comme

 +-+-------+------------------------+ | | | | +-+-------+------------------------+ ^ ^ ^ | | | | | +--- significand | +-- exponent | +---- sign bit 

où vous avez 1 bit pour représenter le signe s (0 pour positif, 1 pour négatif), un certain nombre de bits pour représenter un exposant e et les bits restants pour un significande ou une fraction f . La valeur représentée est s * f * 2 e .

La plage de valeurs pouvant être représentée est déterminée par le nombre de bits de l’exposant. plus il y a de bits dans l’exposant, plus la plage de valeurs possibles est large.

La précision (de manière informelle, la taille de l’écart entre les valeurs pouvant être représentées) est déterminée par le nombre de bits dans le significande. Toutes les valeurs en virgule flottante ne peuvent pas être représentées exactement dans un nombre de bits donné. Plus vous avez de bits dans le significande, plus l’écart entre deux valeurs représentables est petit.

Chaque bit du significande représente 1/2 n , où n est le numéro du bit à partir de la gauche:

  110100... ^^ ^ || | || +------ 1/2^4 = 0.0625 || |+-------- 1/2^2 = 0.25 | +--------- 1/2^1 = 0.5 ------ 0.8125 

Voici un lien que tout le monde devrait avoir marqué: Ce que tout informaticien devrait savoir sur l’arithmétique en virgule flottante .

Deux types avec la même taille en octets peuvent avoir des plages différentes à coup sûr.

Par exemple, int signé et int non signé sont 4 octets, mais l’un des 32 bits est réservé à la signature, ce qui réduit la valeur maximale d’un facteur 2 par défaut. En outre, la plage est différente car celle-ci peut être négative. Les flotteurs, quant à eux, perdent la plage de valeurs au profit de l’utilisation de quelques bits pour la plage décimale.

La norme ne spécifie pas la taille en octets, mais elle spécifie des plages minimales que divers types d’intégraux doivent pouvoir contenir. Vous pouvez en déduire la taille minimale en octets.

Gammes minimales garanties par le standard (à partir de “Types de nombres entiers en C et C ++”):

 signed char: -127 to 127 unsigned char: 0 to 255 "plain" char: -127 to 127 or 0 to 255 (depends on default char signedness) signed short: -32767 to 32767 unsigned short: 0 to 65535 signed int: -32767 to 32767 unsigned int: 0 to 65535 signed long: -2147483647 to 2147483647 unsigned long: 0 to 4294967295 signed long long: -9223372036854775807 to 9223372036854775807 unsigned long long: 0 to 18446744073709551615 

Les valeurs de plage spécifiques à la plate-forme se trouvent dans C ou dans C ++ (ou mieux encore, avec std :: numeric_limits basées sur un modèle dans l’en-tête).

Standard exige seulement que:

sizeof(short int) <= sizeof(int) <= sizeof(long int)

float n'a pas la même "résolution" qu'un int malgré leur taille apparemment similaire. int est un complément à 2 alors que float est composé de 23 bits Mantissa, 8 bits d'exposant et 1 bit de signe.

Vous mélangez la représentation d’un nombre , qui dépend de certaines règles que vous (ou de quelqu’un d’autre) définissez, et de la façon dont vous utilisez le nombre pour le conserver dans l’ordinateur (les octets).

Par exemple, vous pouvez utiliser un seul bit pour conserver un nombre et décider que 0 représente -100 et 1 représente +100. Ou que 0 représente 0,5 et 1 représente 1,0. Les 2 choses, les données et la signification des données, sont indépendantes.

Un entier est juste un nombre … Sa scope dépend du nombre de bits (différent pour un entier signé ou non signé).

Un nombre à virgule flottante est une chose complètement différente. C’est juste une convention sur la représentation d’un nombre à virgule flottante en binary …

Il est codé avec un bit de signe, un champ exposant et une mantisse.

Lire l’article suivant:

http://www.eosgarden.com/fr/articles/float/

Cela vous fera comprendre quelles sont les valeurs à virgule flottante, d’un sharepoint vue binary. Vous comprendrez le truc de la gamme …