Pourquoi unsigned int 0xFFFFFFFF est égal à int -1?

En C ou C++, il est dit que le nombre maximal d'un size_t (unsigned int type de données) peut tenir est la même que la coulée de -1 à ce type de données. voir, par exemple, Valeur non valide pour size_t

Pourquoi?

Je veux dire, (en parlant de 32 bits ints) autant que je sache, le bit le plus significatif détient le signe dans un type de données signées (qui est, peu 0x80000000 pour former un nombre négatif). alors, de 1 est 0 x 00000001.. 0x7FFFFFFFF est le plus grand nombre positif d'une donnée de type int peut tenir.

Puis, autant que je sache, la représentation binaire de -1 int doit être 0x80000001 (peut-être que je me trompe). pourquoi/comment cette valeur binaire est converti en quelque chose de complètement différent (0xFFFFFFFF) lors de la conversion d'entiers non signé?? ou.. comment est-il possible de former un binaire -1 de 0xFFFFFFFF?

Je n'ai aucun doute que, dans C: ((unsigned int)-1) == 0xFFFFFFFF ou ((int)0xFFFFFFFF) == -1 est tout aussi vrai que 1 + 1 == 2, je me demande pourquoi.

  • Lisez à propos de "complément à Deux" sur Wikipédia; c'est le moyen le plus commun de l'encodage des nombres négatifs en binaire.
  • en.wikipedia.org/wiki/Two%27s_complement
  • Vous remarquerez que, tout comme avec les nombres non signés, en ajoutant 1 au plus grand nombre possible vous donnera le plus bas possible.
  • La représentation binaire de négatifs que l'on a d'être que la représentation que les rendements de zéro quand on y est ajouté. C'est 0xFFFFFFFF.
InformationsquelleAutor conejoroy | 2009-12-07
  1. 47

    Le C et le C++ peut s'exécuter sur plusieurs architectures différentes, et les types de machine. Par conséquent, ils peuvent avoir différentes représentations des nombres: en complément à Deux, et Un " complément étant le plus commun. En général, vous ne devriez pas compter sur une représentation particulière dans votre programme.

    Pour entier non signé types (size_t être l'un de ceux-ci), la norme C (et C++ standard aussi, je pense) spécifie précis de dépassement des règles. En bref, si SIZE_MAX est la valeur maximale du type size_t, alors l'expression

    (size_t) (SIZE_MAX + 1)

    est garanti d'être 0, et, par conséquent, vous pouvez être sûr que (size_t) -1 est égal à SIZE_MAX. Le même est vrai pour d'autres types non signés.

    Noter que ce qui précède est vrai:

    • pour tous les types non signés,
    • même si la machine n'est pas de représenter des nombres en complément à Deux. Dans ce cas, le compilateur doit s'assurer de l'identité est vraie.

    Aussi, le ci-dessus signifie que vous ne pouvez pas compter sur les représentations spécifiques pour signé types.

    Modifier: afin de répondre à certains commentaires:

    Disons que nous avons un fragment de code comme:

    int i = -1;
long j = i;

    Il y a une conversion de type dans l'attribution de j. En supposant que int et long ont des tailles différentes (la plupart (tous?] Les systèmes 64 bits), le bit-des schémas, à des emplacements de mémoire pour i et j vont être différents, parce qu'ils ont des tailles différentes. Le compilateur permet de s'assurer que le valeurs de i et j sont -1.

    De même, lorsque nous faisons:

    size_t s = (size_t) -1

    Il y a une conversion de type en cours. Le -1 est de type int. Il a un peu de directivité, mais c'est sans importance pour cet exemple parce que quand la conversion à size_t a lieu en raison de la fonte, le compilateur traduit le valeur selon les règles de type (size_t dans ce cas). Ainsi, même si int et size_t ont des tailles différentes, la norme garantit que la valeur stockée dans s ci-dessus sera la valeur maximale que size_t peut prendre.

    Si nous n':

    long j = LONG_MAX;
int i = j;

    Si LONG_MAX est plus grand que INT_MAX, la valeur de i la mise en œuvre est définie par (C89, la section 3.2.1.2).

    • Voté parce que vous êtes la première personne qui a noté que (size_t)-1 est à cause des règles arithmétiques que C spécifie pour les nombres non signés, non pas à cause de la représentation sous-jacente. (En passant, SIZE_MAX est la macro).
    • Merci! Je ne voulais pas utiliser de SIZE_MAX car il n'est pas en C89, et aussi parce que j'essayais de faire un point général. Pourtant, je pense que j'ai peut-être mentionné.
    • "même si la machine n'est pas de représenter des nombres en complément à deux" - étant donné qu'en complément à deux est une manière de représenter les connecté, comment serait-il jamais s'appliquer à des entiers non signés?
    • Si la norme garantit que SIZE_T_MAX+1 == 0, ne fait que traduire automatiquement à (size_t)-1 == SIZE_T_MAX? Je ne suis pas sûr qu'il fait, surtout si le compilateur a besoin d'émettre un code spécial pour la vérification de cette affaire. Je ne suis même pas sûr que je serais de garantie (size_t) 0 - (size_t) 1 == SIZE_T_MAX. Peut-être que le standard a plus à dire sur le sujet que vous avez implicite, je ne l'ai pas sous la main.
    • Marque: "des entiers non signés doivent obéir aux lois de l'arithmétique modulo 2**n, où n est le nombre de bits dans la représentation de la valeur de la taille de l'entier." [3.9.1/4, C++03]
    • Édité mon post pour avoir des précisions. Voir aussi Roger réponse.
    • merci pour cela. Semble dire (size_t)0 - (size_t)1 donnera la réponse souhaitée. Toujours pas convaincu qu'il s'applique à (size_t)-1 toutefois, depuis que -1 est en dehors de la plage gérée par size_t. P. S. doit-on valoir au sujet des anges sur la pointe d'une épingle après cela?
    • votre modifier de mieux répondu à ma question. Pour le dire en termes simples, peu importe la représentation interne d'un nombre binaire en nombre; il n'est pas pertinent pour le C et ses règles de l'arithmétique des nombres entiers. En conclusion, étant donné qu'il existe différentes configurations matérielles pour entier négatif, il n'y a aucun moyen de les manipuler au niveau des bits en C pour "faire" les nombres négatifs de leurs morceaux, est-ce correct?
    • Il est possible de le faire, mais vous devez être extrêmement prudent, et la solution est la plus probable ne va pas être portable. Tout d'abord, vous besoin de connaître la taille de l'objet sous-jacent (facile, sizeof va le faire). Vous devez également connaître le stockage de la machine (également assez facile, bien qu'il existe quelques pièges - et il pourrait y avoir des systèmes avec de très "bizarre", endianness). Ensuite, votre compilateur peut ajouter rembourrage bits et/ou ont piège des représentations (bit-modèles qui ne font pas de sens). Donc, il est préférable de ne pas le faire.
    • +1 pour la réponse claire. Aimer la façon dont vous le stress de la valeur aspect.
    • concernant "la plupart(tous?) 32 bits des systèmes", je dirais "très peu de systèmes 32 bit". Généralement int et long sont à la fois 32 bits sur les systèmes. Vous obtenez un décalage sur les systèmes 16 bits (16/32), ou de certains systèmes 64 bits (32/64).
    • nice. J'ai sans doute voulu dire, 64 bits au lieu de 32 bits.

    InformationsquelleAutor Alok Singhal
  2. 26

    Il est appelé en complément à deux. Pour faire un nombre négatif, inverser tous les bits puis ajouter 1. Donc, pour convertir de 1 à -1, l'inverser pour 0xFFFFFFFE, puis ajouter 1 à faire 0xFFFFFFFF.

    Pourquoi il est fait de cette façon, Wikipédia dit:

    Le complément à deux, le système a l'avantage de ne pas exiger que l'addition et la soustraction des circuits de scruter les signes des opérandes pour déterminer s'il faut ajouter ou soustraire. Cette propriété en fait un système à la fois plus simple à mettre en œuvre et capable de facilement supporter une plus grande précision en arithmétique.

    • P. S. j'ai travaillé sur un complément de la machine une fois. C'était bizarre, ayant à la fois le zéro positif et négatif de zéro.
    • Tout comme à virgule flottante? les canards
    • Il n'a jamais eu lieu pour moi qu'à virgule flottante négatives de zéro, mais je vois que vous êtes de droite: en.wikipedia.org/wiki/Signed_zero
    • Les anciennes Données de Contrôle de la Cyber-série utilisé en complément. Le langage machine est impair: le standard de comparaison de l'enseignement traiter +0 comme étant supérieur à 0, la norme de l'égalité d'instruction serait de les traiter comme inégal, mais il y a un "est-il égal à zéro?" de l'enseignement que dans l'essence renvoyé true pour -0 et +0 et false pour autre chose. Heureusement, je n'ai jamais eu à traiter beaucoup avec qui. Aussi, heureusement, je n'ai jamais eu à faire à faible niveau de traitement de texte, car il fit de 6 bits 10 caractères pour un mot machine, et en minuscule a été traitée par un mixte de 6 et de 12 bits de la représentation.
    • La réponse ne change pas même si vous êtes sur un " complément de la machine, ou de toute autre étrange machine. Pour plus de détails, veuillez voir ma réponse. Comme un mineur nit, c'est "un " complément", pas "un complément". De Knuth: Un complément à deux nombre est complété à l'égard d'une seule puissance de 2, alors qu'un de ceux de compléter le numéro est complété à l'égard d'une longue séquence de 1s. En effet, il y a aussi un "deux' complément de notation", qui a radix 3 et complémentation à l'égard de (2...22)_3.
    • Félicitations pour deviner la machine où j'ai d'abord appris à l'assemblée. @Alok: je n'étais pas au courant que la norme des garanties de ce genre, je n'ai jamais utilisé le C ou C++ sur toute machine qui n'a pas utilisé en complément à deux. Je devine qu'ils sont extrêmement rares.
    • Rançon: c'est peut-être plus exact de dire "prendre un certain nombre négatif" ou même de "changer le signe d'un nombre" de "faire un nombre négatif". Tant que le bit le plus élevé est défini, vous avez fait un nombre négatif.
    • sur le Contrôle de Données, vous pouvez tricher un peu:si vous avez ajouté de zéro à un nombre, il serait à son tour zéro négatif en positif zéro, ce qui fait des comparaisons simples et directes.

    InformationsquelleAutor Mark Ransom
  3. 7

    Votre première question, pourquoi (unsigned)-1 donne le plus possible de valeur non signée est qu'accidentellement liées à complément à deux. La raison -1 cast pour un type non signé donne la plus grande valeur possible pour que ce type est parce que la norme dit que les types non signés "suivre les lois de l'arithmétique modulo 2n, où n est le nombre de bits dans la représentation de la valeur de la taille de l'entier."

    Maintenant, pour complément de 2, la représentation de la plus grande possible de valeur non signée et -1 sont les mêmes-mais même si le matériel utilise une autre représentation (par exemple, 1 de les compléter ou de les signer et l'ampleur), la conversion de -1 pour un type non signé doit encore produire la plus grande valeur possible pour ce type.

    InformationsquelleAutor Jerry Coffin
  4. 3

    En complément à deux est très agréable pour faire la soustraction comme l'addition 🙂

     11111110 (254 ou -2) 
+00000001 ( 1) 
--------- 
11111111 (255 ou -1) 

11111111 (255 ou -1) 
+00000001 ( 1) 
--------- 
100000000 ( 0 + 256)
    • superbe et claire illustration. Merci!
    InformationsquelleAutor pmg
  5. 1

    Qui est en complément à deux encodage.

    Le principal avantage est que vous obtenez le même encodage que vous utilisez un entier non signé ou signé int. Si vous soustrayez 1 0 l'entier simplement s'enroule autour de. Donc soit 1 de moins que 0 est 0xFFFFFFFF.

    InformationsquelleAutor Goz
  6. -1

    Parce que le motif de bits pour un int
    -1 est FFFFFFFF en hexadécimal non signé.
    11111111111111111111111111111111 binaire non signé.
    Mais en int le premier bit indique si elle est négative.
    Mais en unsigned int le premier bit est juste un numéro supplémentaire en raison d'un unsigned int ne peut pas être négative. De sorte que le bit supplémentaire rend un unsigned int capable de stocker plus grand nombre.
    Comme avec un unsigned int 11111111111111111111111111111111 (binaire) ou FFFFFFFF (hexadécimal) est le plus grand nombre un uint peut stocker.
    Unsigned Ints ne sont pas recommandés car si ils vont négatif, il déborde et va au plus grand nombre.

    • Vous avez juste retraité de l'OP de l'observation et qu'il est demandé pourquoi le motif de bits pour un int, c'est que; et également pourquoi (unsigned int)-1 donne 0xFFFFFFFF (que votre réponse ne répond pas clairement). Aussi, qui est controversée des conseils pour ne pas vous recommandons d'utiliser des entiers non signés. Ils sont très couramment utilisés. Les deux pays ont signé ints et unsigned ints ont pièges. Mon avis est que les entiers non signés ont moins de pièges que la signature de l'ints, donc je préfère les utiliser, sauf si je sais que les valeurs négatives sont nécessaires.
    InformationsquelleAutor trinalbadger587