valeur maximale de l'entier

En C, l'entier (pour une machine 32 bits) est de 32 bits, et il va de -32 768 à +32 767. En Java, l'entier (long) est également de 32 bits, mais varie de -2 147 483 648 à + 2 147 483 647.

Je ne comprends pas en quoi la plage est différente en Java, même si le nombre de bits est le même. Quelqu'un peut-il expliquer cela?

En C , le langage lui-même ne détermine pas la représentation de certains types de données. Il peut varier d'une machine à l'autre, sur les systèmes embarqués, il intpeut avoir une largeur de 16 bits, bien qu'il soit généralement de 32 bits.

La seule exigence est que short int<= int<= long intpar taille. En outre, il existe une recommandation qui intdevrait représenter la capacité native du processeur .

Tous les types sont signés. Le unsignedmodificateur vous permet d'utiliser le bit le plus élevé dans le cadre de la valeur (sinon il est réservé au bit de signe).

Voici un petit tableau des valeurs possibles pour les types de données possibles:

          width                     minimum                         maximum
signed    8 bit                        -128                            +127
signed   16 bit                     -32 768                         +32 767
signed   32 bit              -2 147 483 648                  +2 147 483 647
signed   64 bit  -9 223 372 036 854 775 808      +9 223 372 036 854 775 807
unsigned  8 bit                           0                            +255
unsigned 16 bit                           0                         +65 535
unsigned 32 bit                           0                  +4 294 967 295
unsigned 64 bit                           0     +18 446 744 073 709 551 615

En Java , la spécification du langage Java détermine la représentation des types de données.

L'ordre est le suivant: byte8 bits, short16 bits, int32 bits, long64 bits. Tous ces types sont signés , il n'y a pas de versions non signées. Cependant, les manipulations de bits traitent les nombres comme s'ils n'étaient pas signés (c'est-à-dire en gérant correctement tous les bits).

Le type de données de caractère charest large de 16 bits, non signé et contient des caractères utilisant le codage UTF-16 (cependant, il est possible d'attribuer un charentier arbitraire de 16 bits non signé qui représente un point de code de caractère non valide)

          width                     minimum                         maximum

SIGNED
byte:     8 bit                        -128                            +127
short:   16 bit                     -32 768                         +32 767
int:     32 bit              -2 147 483 648                  +2 147 483 647
long:    64 bit  -9 223 372 036 854 775 808      +9 223 372 036 854 775 807

UNSIGNED
char     16 bit                           0                         +65 535

En C, l'entier (pour une machine 32 bits) est 32 bits et il va de -32768 à +32767.

Faux. Un entier signé 32 bits dans la représentation du complément à 2 a la plage -2 ³¹ à 2 ³¹ -1 qui est égale à -2 147 483 648 à 2 147 483 647.

Un entier 32 bits va de -2 147 483 648 à 2 147 483 647. Cependant, le fait que vous soyez sur une machine 32 bits ne signifie pas que votre Ccompilateur utilise des entiers 32 bits.

La définition du langage C spécifie des plages minimales pour différents types de données. Pour int, cette plage minimale est comprise entre -32767 et 32767, ce qui signifie qu'un intdoit avoir une largeur d' au moins 16 bits. Une mise en œuvre est libre de fournir un inttype plus large avec une gamme correspondante plus large. Par exemple, sur le serveur de développement SLES 10 sur lequel je travaille, la plage est de -2147483647 à 2137483647.

Il existe encore des systèmes qui utilisent des inttypes 16 bits (All The World Is Not A VAX x86), mais il y en a beaucoup qui utilisent des inttypes 32 bits , et peut-être quelques-uns qui utilisent 64 bits.

Le langage C a été conçu pour fonctionner sur différentes architectures. Java a été conçu pour fonctionner sur une machine virtuelle qui cache ces différences architecturales.

L'équivalent strict de la java intest long inten C.

Edit: Si int32_test défini, alors c'est l'équivalent en termes de précision. long intgarantir la précision du java int, car il est garanti d'avoir une taille d'au moins 32 bits.

C'est parce que dans C - entier sur une machine 32 bits ne signifie pas que 32 bits sont utilisés pour le stocker, il peut également être 16 bits. Cela dépend de la machine (dépend de l'implémentation).

L'affiche a leurs types java mélangés. en java, son C in est un court: court (16 bits) = -32768 à 32767 int (32 bits) = -2.147.483.648 à 2.147.483.647

http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

En fait , la taille en bits du int, short, long dépend de la mise en œuvre du compilateur.

Par exemple, sur mon Ubuntu 64 bits, je l'ai shorten 32bits, alors que sur une autre version Ubuntu 32 bits, il est en 16bits.

C'est en fait très simple à comprendre, vous pouvez même le calculer avec la calculatrice google: vous avez 32 bits pour un int et les ordinateurs sont binaires, donc vous pouvez avoir 2 valeurs par bit (spot). si vous calculez 2 ^ 32, vous obtiendrez le 4 294 967 296. donc si vous divisez ce nombre par 2, (parce que la moitié d'entre eux sont des entiers négatifs et l'autre moitié sont positifs), vous obtenez 2 147 483 648. et ce nombre est le plus grand entier pouvant être représenté par 32 bits, bien que si vous faites attention, vous remarquerez que 2147483488 est supérieur à 2147483647 par 1, c'est parce que l'un des nombres représente 0, ce qui est malheureusement au milieu, malheureusement 2 ^ 32 n'est pas un nombre impair, vous n'avez donc pas un seul nombre au milieu, donc les entiers éventuels ont un chiffre de moins tandis que les négatifs obtiennent la moitié complète 2 147 483 648.

Et c'est tout. Cela dépend de la machine et non de la langue.

Dans la plage C pour __int32 est –2147483648 à 2147483647. Voir ici pour les plages complètes.

unsigned short 0 to 65535
signed short –32768 to 32767
unsigned long 0 to 4294967295
signed long –2147483648 to 2147483647

Il n'y a aucune garantie qu'un «int» sera de 32 bits, si vous souhaitez utiliser des variables d'une taille spécifique, en particulier lors de l'écriture de code impliquant des manipulations de bits, vous devez utiliser les «types entiers standard».

En Java

Le type de données int est un entier complément à deux signé 32 bits. Il a une valeur minimale de -2 147 483 648 et une valeur maximale de 2 147 483 647 (inclus).

en standard C, vous pouvez utiliser INT_MAX comme valeur maximale 'int', cette constante doit être définie dans "limits.h". Des constantes similaires sont définies pour d'autres types ( http://www.acm.uiuc.edu/webmonkeys/book/c_guide/2.5.html ), comme indiqué, ces constantes dépendent de l'implémentation mais ont une valeur minimale en fonction des bits minimum pour chaque type, comme spécifié dans la norme.