Comment spécifier un 64 bits unsigned int const 0x8000000000000000 dans VS2008?

J'ai lu sur le Microsoft suffixe spécifique "i64" pour les constantes entières. Je veux faire un UNsigned passage à un ULONGLONG.

ULONGLONG bigNum64 = 0x800000000000000i64 >> myval;

En C normale, je voudrais utiliser le suffixe "U", par exemple, le semblable 32 bits serait

ULONG bigNum32 = 0x80000000U >> myval;

Je ne veux PAS les 2 en complément à l'extension du signe de propager à travers le haut bits. Je veux un UNSIGNED maj sur un 64 bits const nombre. Je pense que ma première déclaration va faire un SIGNÉ décalage à droite.

J'ai essayé 0x800000000000000i64U et 0x800000000000000u64, mais a eu des erreurs de compilation.

  • Dans mon Visual Studio, limits.h a la syntaxe 0xffffffffffffffffui64, donc 0x800000000000000ui64 devrait fonctionner. Cependant, il est une version plus récente, peut-être que cela n'a pas fonctionné dans Visual Studio 2008.
  • U peut être unsigned int, unsigned long int, ou unsigned long long int pour un hex constante entière. UL peut être unsigned long int ou unsigned long long int. Voir 6.4.4.1 de la norme (ou 2.14.3 de la norme C++). Étant donné que, je ne pense pas que l'OP de l'exemple est incorrecte ou a besoin d'être modifié.
  • C'est une vieille question. En C++11, je ne pense pas que tout le suffixe est nécessaire. Seulement un entier non signé de 64 bits de type intégral peut maintenir cette constante. Un unsigned long long doit être d'au moins 64 bits, et c'est sur la liste des types le compilateur doit essayer pour un littéral au format hexadécimal. en.cppreference.com/w/cpp/language/integer_literal
InformationsquelleAutor franji1 | 2010-05-14
  1. 32

    Vous pouvez utiliser le suffixe ull, qui est la norme C99 et C++0x) de spécifier un unsigned long long littéral entier, et un long long est au moins 64 bits.

    • avertissement du Compilateur -Wlong-long peut être désactivée sur le compilateur de ligne de commande ou dans le code avec #pragma GCC diagnostic ignored "-Wlong-long". Voici un bel exemple de le faire à titre temporaire pour une section de code.
    • Vous ne recevrez pas les mises en garde pour tout ce qui concerne long long si vous compiler en C99 mode ou plus.
    • J'ai -std=gnu99 qui est chemin pour compiler en C99 mode dans AtmelStudio. Et je reçois warning: use of C99 long long integer constant [-Wlong-long] je dois activer l'alerte par défaut parce que c'est un 32-bit MCU, et je veux utiliser math 64 bits avec parcimonie.
    • Est-ce vraiment "le chemin" pour compiler en C99 mode? La réponse que vous avez lié ne semble pas dire que la normale -std=c99 ne fonctionne pas. Corrigez-moi si je me trompe, mais pour moi -std=gnu99 sonne comme une préférence personnelle de la personne qui a donné cette réponse (avec certaines holywar-ish attitude, car il n'a même pas pris la peine de mentionner -std=c99).
    • wow peut-être que l'intrigue est plus épais que je ne le pensais. Vous dites que dans la vraie mode C99 il devrait y avoir aucun moyen d'activer les avertissements sur LL suffixes? Que -Wlong-long ne fait rien? Ou juste que c'est désactivé par défaut.
    • Il devrait y avoir un moyen de leur permettre, si vous le désirez à l'aide d'un explicite -Wlong-long. Mais je m'attends à être désactivé par défaut.

    InformationsquelleAutor James McNellis
  2. 11

    Assez drôle, mais vous n'avez pas besoin d'ajouter un suffixe à votre hex constant pour être traités correctement. Section 6.4.4.1 de la norme et à l'article 2.14.3 de la norme C++ contient le tableau suivant:

    Suffix       | Decimal Constant       | Octal or Hexadecimal Constant
-------------+------------------------+------------------------------
none         | int                    | int
             | long int               | unsigned int
             | long long int          | long int
             |                        | unsigned long int
             |                        | long long int
             |                        | unsigned long long int
-------------+------------------------+------------------------------
u or U       | unsigned int           | unsigned int
             | unsigned long int      | unsigned long int
             | unsigned long long int | unsigned long long int
-------------+------------------------+------------------------------
l or L       | long int               | long int
             | long long int          | unsigned long int
             |                        | long long int
             |                        | unsigned long long int
-------------+------------------------+------------------------------
Both u or U  | unsigned long int      | unsigned long int
and l or L   | unsigned long long int | unsigned long long int
-------------+------------------------+------------------------------
ll or LL     | long long int          | long long int
             |                        | unsigned long long int
-------------+------------------------+------------------------------
Both u or U  | unsigned long long int | unsigned long long int
and ll or LL |                        |

    Ce tableau nous indique quel est le type d'une constante entière aura. La constante entière de type sera le premier type dont la valeur est adaptée.

    Cela signifie que le compilateur va itérer sur les types suivants pour la constante hexadécimale 0x800000000000000 (il n'a pas de suffixe, de sorte qu'il utilise le "non" de ligne, et c'est un hex constante, de sorte qu'il utilise la "Constante Hexadécimale" colonne), et il utilise le premier type qui peut stocker cette valeur*:

    1. int: Non, un entier signé 32 bits ne peuvent pas stocker cette valeur.
    2. unsigned int: Non, non signé de 32 bits entier ne peut pas stocker cette valeur.
    3. long int: Non, un entier signé 32 bits ne peuvent pas stocker cette valeur.
    4. unsigned long int: Non, non signé de 32 bits entier ne peut pas stocker cette valeur.
    5. long long int: Non, un 64-bits entier signé ne peut pas stocker cette valeur.
    6. unsigned long long int: Oui, un 64-bit unsigned integer peut stocker cette valeur. Puisque c'est le premier type capable de stocker de la valeur, c'est le type de la constante entière aura.

    Donc pour répondre à ta question de "Comment écrire et utiliser la valeur 0x800000000000000 et assurez-vous que le compilateur ne pas traiter la haute peu comme un bit de signe?": Il suffit juste d'écrire unsigned long long value = 0x800000000000000.

    Si vous voulez faire un peu de bit-à-bit de l'arithmétique, de la valeur, vous pouvez simplement aller de l'avant et de le faire (c'est à dire il suffit d'écrire 0x800000000000000 >> myval). Vous avez la garantie qu'il ne sera pas traitée comme une débordé entier signé, et votre maj de droite ne pourra pas faire l'extension du signe parce que c'est une valeur positive.

    *je suis en supposant que int 32-bits, long 32-bits, et long long est 64-bits. Notez que votre compilateur peut utiliser différents bits tailles pour ces types, qui peuvent changer le résultat final (bien que le processus reste le même).

    • Vous devez être prudent, cependant. Si vous voulez déclarer un unsigned long long sans suffixe, alors vous allez avoir des ennuis: considérer printf("%lx\n", (0x40000000<<1)>>1); La gauche/droite du poste de redonner 0x40000000, mais si vous exécutez ce code, vous obtiendrez 0xc0000000.
    • à l'aide de %l traite de la valeur d'un entier signé ou signé de long. Si vous prenez les 2 en complément de 0xc0000000 vous obtiendrez 0x40000000, mais cela pourrait représenter un nombre négatif. Les tiges de maïs est correct, parce que la valeur a été déclarée comme unsigned long long. Si je les déclare comme signé ints puis-je obtenir 0xc0000000:
    • Je n'ai pas pu terminer mon commentaire: printf("%lx\n", (0x40000000<<1)>>1); // traite les valeurs signé à la place de non signé. unsigned int a = 0x40000000; unsigned int b = a<<1; unsigned int c = b>>1; printf("%lx\n", c); // vous obtiendrez 0x40000000. C'est parce que sans suffixe, aucune ligne est utilisé et les deux 0x40000000, 0x80000000, et 0xc0000000 peuvent être représentés par des entiers signés. Ce qui est exactement ce que les tiges de maïs dit, et ils sont corrects.
    • En outre, printf est par défaut non signé hex sans un spécificateur de format, mais ce que le format spécificateur n'est pas la même chose qu'une constante spécificateur qui va après une valeur constante. Pour imprimer les valeurs de 64 bits avec printf, %lx doit être utilisé, et vous devez définir une variable du type approprié, mais là encore ce n'est que pour l'impression et n'a aucun effet sur les opérations arithmétiques. Il convient de noter que le compilateur c++ g++, etc) va permettre cela: unsigned long long int k = 0x800000010000000; unsigned int z =k; z sera 0x10000000.
    InformationsquelleAutor Cornstalks