(-2147483648> 0) renvoie vrai en C ++?

-2147483648 est le plus petit entier pour le type entier avec 32 bits, mais il semble qu'il débordera dans la if(...)phrase:

if (-2147483648 > 0)
    std::cout << "true";
else
    std::cout << "false";

Cela s'imprimera truedans mes tests. Cependant, si nous convertissons -2147483648 en entier, le résultat sera différent:

if (int(-2147483648) > 0)
    std::cout << "true";
else
    std::cout << "false";

Cela s'imprimera false.

Je suis confus. Quelqu'un peut-il donner une explication à ce sujet?

Mise à jour 02-05-2012:

Merci pour vos commentaires, dans mon compilateur, la taille de int est de 4 octets. J'utilise VC pour des tests simples. J'ai changé la description dans ma question.

C'est beaucoup de très bonnes réponses dans ce post, AndreyT a donné une explication très détaillée sur la façon dont le compilateur se comportera sur une telle entrée, et comment cet entier minimum a été implémenté. qPCR4vir , d'autre part, a donné quelques "curiosités" et comment les nombres entiers sont représentés. Tellement impressionnant!

-2147483648n'est pas un "nombre". Le langage C ++ ne prend pas en charge les valeurs littérales négatives.

-2147483648 est en fait une expression: une valeur littérale positive 2147483648 avec un -opérateur unaire devant elle. La valeur 2147483648est apparemment trop grande pour le côté positif de la intplage sur votre plate-forme. Si le type long intavait une plus grande plage sur votre plateforme, le compilateur devrait automatiquement supposer qu'il 2147483648a le long inttype. (En C ++ 11, le compilateur devrait également prendre en compte le long long inttype.) Cela obligerait le compilateur à évaluer -2147483648dans le domaine de type plus grand et le résultat serait négatif, comme on pourrait s'y attendre.

Cependant, dans votre cas, la plage de long intest la même que la plage de int, et en général, il n'y a pas de type entier avec une plage plus grande que intsur votre plate-forme. Cela signifie formellement que la constante positive2147483648 déborde de tous les types d'entiers signés disponibles, ce qui signifie que le comportement de votre programme n'est pas défini. (Il est un peu étrange que la spécification du langage opte pour un comportement non défini dans de tels cas, au lieu d'exiger un message de diagnostic, mais c'est ainsi.)

Dans la pratique, la prise en compte du fait que le comportement n'est pas défini 2147483648peut être interprétée comme une valeur négative dépendante de l'implémentation qui devient positive après avoir été -appliquée à l'unary. Alternativement, certaines implémentations peuvent décider d'essayer d'utiliser des types non signés pour représenter la valeur (par exemple, en C89 / 90, les compilateurs devaient utiliser unsigned long int, mais pas en C99 ou C ++). Les implémentations sont autorisées à faire n'importe quoi, car le comportement n'est pas défini de toute façon.

En remarque, c'est la raison pour laquelle les constantes comme INT_MINsont généralement définies comme

#define INT_MIN (-2147483647 - 1)

au lieu de ce qui semble plus simple

#define INT_MIN -2147483648

Ce dernier ne fonctionnerait pas comme prévu.

Le compilateur (VC2012) promeut les entiers "minimum" pouvant contenir les valeurs. Dans le premier cas, signed int(et long int) ne peut pas (avant l'application du signe), mais unsigned intpeut: 2147483648aunsigned int ???? type. Dans la seconde, vous forcez à intpartir du unsigned.

const bool i= (-2147483648 > 0) ;  //   --> true

avertissement C4146: opérateur unaire moins appliqué au type non signé , résultat toujours non signé

Voici des "curiosités" liées:

const bool b= (-2147483647      > 0) ; //  false
const bool i= (-2147483648      > 0) ; //  true : result still unsigned
const bool c= ( INT_MIN-1       > 0) ; //  true :'-' int constant overflow
const bool f= ( 2147483647      > 0) ; //  true
const bool g= ( 2147483648      > 0) ; //  true
const bool d= ( INT_MAX+1       > 0) ; //  false:'+' int constant overflow
const bool j= ( int(-2147483648)> 0) ; //  false : 
const bool h= ( int(2147483648) > 0) ; //  false
const bool m= (-2147483648L     > 0) ; //  true 
const bool o= (-2147483648LL    > 0) ; //  false

Norme C ++ 11 :

2.14.2 Littéraux entiers [lex.icon]

…

Un littéral entier est une séquence de chiffres sans période ni partie exposante. Un littéral entier peut avoir un préfixe qui spécifie sa base et un suffixe qui spécifie son type.

…

Le type d'un littéral entier est le premier de la liste correspondante dans laquelle sa valeur peut être représentée.

Si un littéral entier ne peut être représenté par aucun type dans sa liste et qu'un type entier étendu (3.9.1) peut représenter sa valeur, il peut avoir ce type entier étendu. Si tous les types de la liste du littéral sont signés, le type entier étendu doit être signé. Si tous les types de la liste pour le littéral ne sont pas signés, le type entier étendu doit être non signé. Si la liste contient à la fois des types signés et non signés, le type entier étendu peut être signé ou non signé. Un programme est mal formé si l'une de ses unités de traduction contient un littéral entier qui ne peut être représenté par aucun des types autorisés.

Et ce sont les règles de promotion des entiers dans la norme.

4.5 Promotions intégrales [conv.prom]

A prvalue d'un type entier autre que bool, char16_t, char32_t, ou wchar_tdont le rang entier conversion (4,13) est inférieur au rang d'int peut être converti en un prvalue de type intsi intpeut représenter toutes les valeurs du type de source; sinon, la valeur source peut être convertie en valeur de type unsigned int.

En bref, 2147483648déborde -2147483648et (-(-2147483648) > 0)est true.

Voilà à quoi 2147483648ressemble en binaire.

De plus, dans le cas de calculs binaires signés, le bit le plus significatif ("MSB") est le bit de signe. Cette question peut aider à expliquer pourquoi.

Parce que -2147483648c'est en fait 2147483648avec la négation ( -) qui lui est appliquée, le nombre n'est pas celui que vous attendez. C'est en fait l'équivalent de ce pseudocode:operator -(2147483648)

Maintenant, en supposant que votre compilateur est sizeof(int)égal à 4et CHAR_BITest défini comme 8, cela ferait 2147483648déborder la valeur maximale signée d'un entier ( 2147483647). Alors, quel est le maximum plus un? Permet de travailler avec un entier de complément de 4 bits et 2 s.

Attendre! 8 déborde l'entier! Qu'est-ce qu'on fait? Utilisez sa représentation non signée 1000et interprétez les bits comme un entier signé. Cette représentation nous laisse avec l' -8application de la négation du complément 2s qui en résulte 8, qui, comme nous le savons tous, est supérieure à 0.

C'est pourquoi <limits.h>(et <climits>) se définissent généralement INT_MINcomme ((-2147483647) - 1)- de sorte que l'entier signé maximum ( 0x7FFFFFFF) soit nié ( 0x80000001), puis décrémenté ( 0x80000000).