Opération de comparaison sur non signés et les entiers signés

Voir cet extrait de code

int main()
{ 
 unsigned int a = 1000;
 int b = -1;
 if (a>b) printf("A is BIG! %d\n", a-b);
 else printf("a is SMALL! %d\n", a-b); 
 return 0;
}

Cela donne à la sortie: un est PETIT: 1001

Je ne comprends pas ce qui se passe ici. Comment l' > opérateur de travailler ici? Pourquoi est-ce "un" plus petit que "b"? Si il est en effet plus petit, pourquoi dois-je obtenir un nombre positif (1001) comme la différence?

  • Si vous utilisez le Wsign-comparer compilateur drapeau, vous obtiendrez un avertissement pour la comparaison. Vous devriez toujours utiliser -Mur (qui comprend Wsign-comparer). Voir ici pour d'autres façons d'éviter ce problème.
  • Voir ce post pour plus d'info: stackoverflow.com/q/10474769/844882
  • techniquement ce n'est pas tout à fait droit, -Wsign-comparer n'est inc. avec -Mur si vous êtes à la compilation C++. Il n'est pas inclus pour C (voir ici gcc.gnu.org/onlinedocs/gcc/Warning-Options.html) je l'ai testé et je peux confirmer le code ci-dessus donne pas d'avertissement à -Mur, mais ne avec -Wsign-comparer (je suis en utilisant gcc (Ubuntu 5.2.1-22ubuntu2) 5.2.1 20151010)
InformationsquelleAutor Gitmo | 2010-01-18
  1. 46

    Opérations binaires entre les différents types intégraux sont effectuées au sein d'un "bien commun" type défini par d'habitude arithmétique des conversions (voir la spécification du langage, 6.3.1.8). Dans votre cas, la "commune" de type est unsigned int. Cela signifie que int opérande (votre b) seront converties à unsigned int avant la comparaison, ainsi que pour l'exercice de la soustraction.

    Quand -1 est converti à unsigned int le résultat est le maximum possible unsigned int valeur (le même que UINT_MAX). Inutile de dire, il va être plus grand que votre unsigned 1000 valeur, ce qui signifie que a > b est en effet faux et a est en effet petit par rapport à (unsigned) b. Le if dans votre code doit se résoudre à else branche, qui est ce que vous avez observé dans votre expérience.

    Les mêmes règles de conversion s'appliquent à la soustraction. Votre a-b est vraiment interprété comme a - (unsigned) b et le résultat est de type unsigned int. Cette valeur ne peut pas être imprimé avec %d spécificateur de format, depuis %d ne fonctionne qu'avec signé valeurs. Votre tentative de l'imprimer avec %d entraîne un comportement non défini, de sorte que la valeur que vous voyez imprimé (même si elle a une logique déterministe explication dans la pratique) est complètement dénuée de sens du point de vue du langage C.

    Edit: en Fait, j'ai peut-être tort sur le comportement indéfini de la partie. Selon C spécification du langage, la partie commune de la gamme de correspondants signés et non signés, de type entier doit avoir la même représentation (ce qui implique, selon la note de bas de page 31, "l'interchangeabilité que les arguments de fonctions"). Alors, le résultat de a - b expression est non signé 1001 comme décrit ci-dessus, et si je suis absent quelque chose, il est légal pour imprimer cette valeur non signée avec %d prescripteur, car elle s'inscrit dans la plage positive de int. L'impression (unsigned) INT_MAX + 1 avec %d serait pas défini, mais 1001u est fine.

    • Bien que nous savons ou peut deviner assez sur la convention d'appel de sa mise en œuvre à conclure que ce qui est arrivé, c'est le non signé résultat de a-b, qui est, en fait, 1001, a été transmis à travers les varargs indemne, et réinterprété comme l'ont signé sans modification de la valeur.
    • Ouais en passant unsigned int et faire va_arg(ap, int) seul n'est pas UB encore. Mais c'est en effet UB violer printf aux besoins attend à une int. Il semble stupide pour moi, si. Pourquoi n'ont-ils pas précisé pour le printf: "Le type de l'argument suivant doit être signé ou unsigned int, et sont dans la gamme de l'int".
    • En fait, il sera peut-être déjà spécifié. Voir mon edit.
    • Mais si elle est compatible avec la représentation n'est pas important, je pense. Si le Standard dit que quelque chose est UB, alors il est UB: C'est pas bientôt remplacer par un énoncé dans une note de bas de page. Je pense que cela signifie qu'il ya une certaine gamme de freedome vous pouvez le faire, sans que les exigences sur la partie de la norme. Comme avec la lecture de différents membres de l'union (ce n'est pas UB à l'avant en C, je pense, mais peut être bien défini si les deux membres sont compatibles représentations). Mais l'appel d'une fonction par le biais d'un prototype-moins de pointeur de fonction à l'expression incompatible avec les arguments de séjours à l'UB, par exemple.
    • Dans ce cas, fprintf description unis: (pour %d): "L'argument int est converti à ..." et "Si aucun argument n'est pas le type correct pour la spécification de conversion, le comportement est indéfini.". Donc je ne crois pas que c'est bien définie. Peut-être quelqu'un de usenet sait?
    • Je ne peux pas le comprendre, à partir 6.2.6.2, mais je pense que le standard compare uniquement la valeur des bits de correspondants signés et non signés, les types intégraux, pas tout rembourrage bits. Est-il légal pour une mise en œuvre d'ignorer le rembourrage bits unsigned int, mais pour tout rembourrage ensemble de bits en int pour être un piège de la représentation? Je ne sais pas, mais si oui, alors les 1001 généré peut juste arriver à avoir un peu de rembourrage, et donc de réinterpréter comme int seraient U. B. ne Pas dire forcément qu'il y a tout de gcc cibles avec un rembourrage bits int, laisser seuls avec cette étrange propriété...
    • Quelle est la règle dans les cas suivants: x = 10 +- 10u + 10u +- 10;? X signés ou non signés donne le même résultat!

    InformationsquelleAutor AnT
  2. 14

    Sur une implémentation typique où int est de 32 bits, -1 lors de la conversion d'un unsigned int est 4,294,967,295 qui est en effet ≥ 1000.

    Même si vous traiter de la soustraction dans un unsigned monde, 1000 - (4,294,967,295) = -4,294,966,295 = 1,001 qui est ce que vous obtenez.

    C'est pourquoi gcc va cracher un avertissement lorsque vous comparez unsigned avec signed. (Si vous ne voyez pas un avertissement, passer le -Wsign-compare drapeau.)

    • Je downvoted en raison de "4,294,967,295 (complément de 2)". Il n'a rien à voir avec le complément de 2. Il donnera la même valeur sur un 1er complément de la machine. Et donner une valeur différente sur un autre bitwidth entier.
    • Peut-être que je ne suis pas clair, mais ce que je veux dire, c'est 4,294,967,295 (qui est complément de 2 de 1), est en effet ≥1. Aussi, le 1er complément de la machine de la représentation de -1 est 4,294,967,294.
    • comme litb dit, il n'a rien à voir avec la représentation. Sur un 1s' complément de la machine, la conversion -1 non signé résultats dans UINT_MAX, il n'a pas en l'1s' complément modèle binaire d'être réinterprété. Une des nombreuses façons dont 2 en complément qui est pratique, c'est que C (onu)ont signé des conversions de ne pas modifier la séquence de bits. C'est notamment pour complément de 2: le C conversions de types non signés sont définies en termes d'arithmétique modulo, non pas en termes de modèle de bits. Sur 1s' complément, la mise en œuvre est de faire une partie du travail réel à venir avec UINT_MAX.
    • la modification est mieux, mais encore il n'y a aucune garantie que UINT_MAX est 4,294,967,295. Voir aussi stackoverflow.com/questions/1863153
    InformationsquelleAutor kennytm
  3. 0

    Vous faites unsigned comparaison, c'est à dire la comparaison de 1000 à 2^32 - 1.

    La sortie est signé en raison de %d dans le printf.

    N. B. parfois, le comportement lorsque vous mélangez les entiers signés et non signés opérandes est spécifique au compilateur. Je pense que c'est mieux de les éviter et de ne jette dans le doute.

    • La soustraction n'est pas de faire quoi que ce soit signé. La soustraction est la même opération pour les deux signés et non signés valeurs.
    • Incorrect, la soustraction entre int et unsigned int opérandes sont évalués comme non signés, la soustraction et le résultat est, bien sûr, non signé.
    • AndreyT est juste, le vrai problème est le %d dans le printf
    InformationsquelleAutor Antti Huima
  4. 0

    Trouver un moyen facile de comparer, peut-être utile lorsque vous ne pouvez pas vous débarrasser de non signé de déclaration (par exemple, [NSArray count]), juste à la force de la "unsigned int" à un "int".

    S'il vous plaît corrigez-moi si je me trompe.

    if (((int)a)>b) {
    ....
}
    InformationsquelleAutor chenyi1976
  5. 0

    Le matériel est conçu pour comparer signé signé et non signé non signé.

    Si vous souhaitez que l'arithmétique de raison, de convertir la valeur non signée à un plus grand type signé en premier. Sinon le compilateur supposera que la comparaison est vraiment entre des valeurs non signées.

    Et -1 est représenté comme 1111..1111, de sorte qu'il a une très grande quantité ... Le plus gros ... s'il est interprété comme non signé.

    • Le matériel peut ne pas avoir de l'arithmétique fonctionnalité de comparaison (comme un dédié comparer ou de soustraire de l'instruction), et pourtant, ces matériels peuvent encore être utilisés pour exécuter des programmes C. Le matériel est important, mais au-delà de la portée du langage de programmation tel que défini par la norme du langage.
    InformationsquelleAutor DigitalRoss
  6. 0
     #include<stdio.h>
 int main()
 {
   int a = 1000;
   signed int b = -1, c = -2;
   printf("%d",(unsigned int)b);
   printf("%d\n",(unsigned int)c);
   printf("%d\n",(unsigned int)a);

   if(1000>-1){
      printf("\ntrue");
   }
   else 
     printf("\nfalse");
     return 0;
 }

    Pour cela, vous devez comprendre la priorité des opérateurs

    1. Opérateurs relationnels œuvres de gauche à droite ...
      alors quand il s'agit

      si(1000>-1)

    alors tout d'abord il va changer -1 non signé entier, car int par défaut est traité comme non signé nombre et de la portée de la plus grande que l'signé nombre

    -1 changement dans le nombre non signé ,il se transforme en un très grand nombre

    InformationsquelleAutor harsh
  7. -1

    tout en comparant les a>b, où a est de type unsigned int et b est de type int, b est de type coulé à unsigned int signée int valeur -1 est convertie en une valeur MAX de non signé**(plage: 0 à (2^32)-1 )**
    Ainsi, a>b, c'est à dire, (1000>4294967296) devient faux. Donc le reste de la boucle printf("a est plus PETIT! %d\n", a-b); exécuté.

    • C'est un moindre effort de duplicata de haut voté répondre
    • tout en étudiant nous venons de reproduire ce qui est déjà l'objet de recherches.
    • mais le but est toujours d'améliorer ce qui est déjà en place.
    InformationsquelleAutor Naveen Kumar