typecasting de non signé dans C

int a = -534;
unsigned int b = (unsigned int)a;
printf("%d, %d", a, b);

imprime -534, -534

Pourquoi le transtypage de ne pas prendre de place?

Je m'attendais à être -534, 534

Si j'ai modifier le code pour 

int a = -534;
unsigned int b = (unsigned int)a;
if(a < b)
  printf("%d, %d", a, b);

ses pas l'impression de rien... après tout a est à moins de b??

  • Vous voulez probablement vérifier votre compilateur docs et de voir si il ya une option pour vérifier printf spécificateurs de format. gcc a -Wformat, qui vous aura prévenu sur le %d et %u chose au moment de la compilation.
  • stackoverflow.com/questions/50605/...
  • Cela ne devrait pas avoir un C++ tag.
InformationsquelleAutor Lazer | 2010-03-01
  1. 4

    Tout d'abord, vous n'avez pas besoin de les jeter: la valeur de a est implicitement converti à unsigned int avec pour mission de b. Si votre déclaration est équivalent à:

    unsigned int b = a;

    Maintenant, une propriété importante de unsigned partie intégrante des types en C et C++, c'est que leurs valeurs sont toujours dans la gamme [0, max], où max pour unsigned int est UINT_MAX (il est défini dans limits.h). Si vous assignez une valeur qui n'est pas dans cette plage, il est converti à cette gamme. Donc, si la valeur est négative, vous ajoutez UINT_MAX+1 à plusieurs reprises à le faire dans l'intervalle [0, UINT_MAX]. Pour votre code ci-dessus, c'est comme si on écrivait: unsigned int b = (UINT_MAX + a) + 1. Ce n'est pas égal à -a (534).

    Noter que ce qui précède est vrai, que le sous-jacent est la représentation en complément à deux, les compléter, ou le signe-amplitude (ou tout autre exotique de l'encodage). On peut voir qu'avec quelque chose comme:

    signed char c = -1;
unsigned int u = c;
printf("%u\n", u);
assert(u == UINT_MAX);

    Sur un typique en complément à deux de la machine avec un 4 octets int, c est 0xff, et u est 0xffffffff. Le compilateur doit faire en sorte que lorsque la valeur -1 est attribué à u, il est converti en une valeur égale à UINT_MAX.

    Maintenant, pour en revenir à votre code, le printf chaîne de format est mauvais pour b. Vous devez utiliser %u. Lorsque vous le faites, vous trouverez qu'il imprime la valeur de UINT_MAX - 534 + 1 au lieu de 534.

    Quand utilisé dans l'opérateur de comparaison <, depuis b est unsigned int, a est également converti unsigned int. Ce, compte tenu de avec b = a; plus tôt, signifie que a < b est faux: a comme un unsigned int est égal à b.

    Disons que vous avez un de ceux que complément de la machine, et vous n':

    signed char c = -1;
unsigned char uc = c;

    Disons un char (signés ou non) est de 8-bits sur cette machine. Puis c et uc va stocker les valeurs suivantes et bit-motifs:

    +----+------+-----------+
| c  |  -1  | 11111110  |
+----+------+-----------+
| uc | 255  | 11111111  |
+----+------+-----------+

    Noter que les modèles de bits de c et uc ne sont pas les mêmes. Le compilateur doit s'assurer que c a la valeur -1, et uc a la valeur UCHAR_MAX, qui est de 255 sur cette machine.

    Il y a plus de détails sur ma réponse à une question sur SI.

    InformationsquelleAutor Alok Singhal
  2. 15

    Parce que vous utilisez %d pour l'impression. Utilisation %u non signés. Depuis printf est une vararg fonction, il ne peut pas savoir les types des paramètres et doit plutôt s'appuyer sur les spécificateurs de format. Pour cette raison, le type de fonte de vous n'a aucun effet.

    • En fait, la valeur non signée obtient reinterpret_cast-ed vers par printf(), en raison de %d. %d signifie "prendre de la valeur et de l'interpréter comme signé int"
    • Yep. Selon la Norme, un comportement indéfini résultats (pas en général pour les variadic fonction printf en particulier).
    • Pourquoi le if échec? Veuillez voir le édités ques.
    • Parce que, une opération portant sur un unsigned argument est réalisé avec des unsigned l'arithmétique. Ainsi implicitement jette un non signé avant la comparaison.
    • La conversion d'une valeur négative à une unsigned int valeur ne doit pas nier (changer de -534 à 534), il convertit le plus petit nombre positif qui est d'ailleurs conforme à l'original modulo UINT_MAX + 1. Si vous avez 32 bits unsigned ints, -534 convertir à 4294966762 (sur un 2s complément de la machine, ce qui a le même bit à bit de la représentation comme -534).
    • Ils ne sont pas reinterpret_cast-ed. printf() est une fonction C. Ils sont juste coulé.
    • Je ne voulais pas dire une opération de reinterpret_cast, je voulais simplement dire la sémantique: la représentation binaire est interprété comme int, sans égard qui était le type de l'argument. En C++ (que nous sommes tous familiers avec) cette sémantique est exprimée par reinterpret_cast, alors qu'en C le casting est un mélange de différents sémantique (au moins à partir de C++ point de vue).

    InformationsquelleAutor Tronic
  3. 4

    votre prescripteur dans le printf est de poser des printf pour imprimer un entier signé, de sorte que le sous-jacent octets sont interprétés comme un entier signé.

    Vous devez spécifier que vous voulez un entier non-signé par l'aide de %u.

    edit: a==b est vrai pour la comparaison, ce qui est étrange comportement, mais il est parfaitement valide. Vous n'avez pas changé le sous-jacent bits vous n'avez qu'a demandé le compilateur de traiter le sous-jacent bits dans une certaine manière. Par conséquent, une comparaison bit à bit des rendements vrai.

    [speculation] Je suppose que le comportement est susceptible de varier entre compilateur implémentations, c'est à dire, un faux PROCESSEUR peut pas utiliser la même logique pour les deux signés et non signés, les chiffres dans ce cas, une comparaison bit à bit serait un échec. [/speculation]

    • Je ne pense pas que vous avez écrit ce que vous avez voulu écrire 🙂
    • Et oui c'est correct, en plus je suis dyslexique hehe.
    • Pourquoi le if échec? Veuillez voir le édités question.
    • Comme l'a dit, parce que a est égal à b, il n'est pas moins de. Les données sous-jacente est la même. Vous devez regarder pour les avertissements du compilateur pour spot choses comme celles-ci (C4018 est un le code ci-dessus serait de déclenchement) msdn.microsoft.com/en-us/library/y92ktdf2%28VS.80%29.aspx
    • Comme indiqué dans un autre commentaire par quelqu'un d'autre, ce comportement de la comparaison sera le même sur tous les compilateur C/combinaisons.
    • Hassan, l'égalité n'est pas due à la sous-jacentes bits, mais parce que la norme de garanties, afin. Même dans le cas de signe-amplitude de codage par exemple, où a et b ont différents bits, a == b est vrai. Voir ma réponse pour plus de détails.

    InformationsquelleAutor Hassan Syed
  4. 1

    C peut être une vilaine bête parfois. Le problème est que -534 représente toujours la valeur 0xfffffdea si elle est stockée dans une variable de type unsigned int ou signé int. Pour comparer ces variables, ils doivent être du même type donc, on sera automatiquement converti vers un entier non signé ou signé int pour correspondre à l'autre. Une fois qu'ils sont du même type, ils sont égaux, car ils représentent la même valeur.

    Il semble probable que le comportement que vous voulez est fourni par la fonction abs:

    int a = -534;
int b = abs(a);
printf("%d, %d", a, b);
    • Notez que le nombre de f dans 0xfffffdea peut varier. E. g. sur les 16 bits de machines, il est juste 0xfdea et 64 bits des machines, vous aurez 13 f est suivi par dea.
    • Tout à fait raison. Je pensais quand j'ai écrit la réponse que je dois oublier quelque chose à propos int taille, mais j'ai pensé qu'il pourrait l'encombrement de la réponse avec l'information qui n'était pas particulièrement pertinents pour le problème à portée de main.
    • Plus important encore, même le dea partie n'est pas nécessairement correcte, sur un signe de grandeur ou un " complément de la machine.
    InformationsquelleAutor Russ Hayward
  5. 0

    Je suppose que le premier cas d'pourquoi b est imprimé en -534 a été répondu de façon satisfaisante Tronic et Hassan. Vous ne devriez pas utiliser %d et devrait être à l'aide de %u.

    En ce qui concerne votre deuxième cas est concered, encore un implicite typecasting qui va se passer et à la fois a et b sera de même en raison de laquelle votre comparaison ne tient rendement le résultat attendu.

    InformationsquelleAutor Jay
  6. 0

    Aussi loin que je peux voir, le si échoue parce que le compilateur suppose la deuxième variable doit être considéré comme le même type que le premier. Essayez
    si(b > a)
    pour voir la différence.

    • Cette réponse est tout simplement faux: dans un essai comparant a signé int avec un unsigned int, la signature de l'int est converti en un unsigned int. Les deux (a < b) et (a > b) sont faux car (a == b).
    • Les deux (a < b) et (a > b) sont faux, Mais ni l'un est si(b > un). Mon compilateur est d'accord.
    InformationsquelleAutor Arthur Kalliokoski
  7. 0

    Re 2e question:
    la comparaison ne fonctionne jamais entre deux types différents - ils sont toujours implicitement convertie au "plus petit dénominateur commun", qui dans ce cas sera unsigned int. Méchant et contre-intuitif, je sais.

    • Si c'est le cas ne pas le cast prendre -534 à zéro, ou de provoquer une exécution de la faute ? J'ai compilé le code dans VS2008 et a==b est vrai.
    • Pas - la fonte de -534 à unsigned int est autorisée dans les deux cas (cas n ° 1 lors de l'initialisation de b, et le cas n ° 2 lors de la comparaison de a et b).
    InformationsquelleAutor SF.
  8. 0

    Le coulage d'un type entier de signé non signé ne modifie pas la séquence de bits, il change simplement l'interprétation de la séquence de bits.

    Vous disposez également d'un spécificateur de format disparité, %u doit être utilisé pour des entiers non signés, mais même alors, le résultat ne sera pas 534 comme vous vous attendez, mais 4294966762.

    Si vous souhaitez apporter une valeur négative positive, il suffit de le nier:

    unsigned b = (unsigned)-a ;
printf("%d, %u", a, b);

    Comme pour le deuxième exemple, les opérations entre les types avec différents signé-ness impliquer les arcanes de la conversion implicite des règles d'éviter. Vous devez définir votre compilateur de niveau d'alerte élevé pour piéger un grand nombre de ces erreurs. Je suggère /W4 /WX dans VC++ et -Wall-Werror -Wformat pour GCC par exemple.

    InformationsquelleAutor Clifford