Énumération 64 bits en C ++?

Question

Existe-t-il un moyen d'avoir une énumération 64 bits en C ++? Lors de la refactorisation de certains codes, je suis tombé sur un tas de #défines qui seraient meilleurs en tant qu'énum, ??mais être supérieurs à 32 bits provoquait une erreur du compilateur.

Pour une raison quelconque, j’ai pensé que les solutions suivantes pourraient fonctionner:

enum MY_ENUM : unsigned __int64  
{  
    LARGE_VALUE = 0x1000000000000000,  
};

Answer 1

Je ne pense pas que ce soit possible avec C ++ 98. La représentation sous-jacente des énumérations appartient au compilateur. Dans ce cas, vous feriez mieux d'utiliser:

const __int64 LARGE_VALUE = 0x1000000000000000L;

À partir de C ++ 11, il est possible d'utiliser des classes enum pour spécifier le type de base de l'énum:

enum class MY_ENUM : unsigned __int64 {
    LARGE_VALUE = 0x1000000000000000ULL
};

De plus, les classes enum introduisent une nouvelle portée de nom. Ainsi, au lieu de faire référence à LARGE_VALUE , vous référencez MY_ENUM :: LARGE_VALUE .

Answer 2

C ++ 11 le supporte en utilisant la syntaxe suivante:

enum class Enum2 : __int64 {Val1, Val2, val3};

Answer 3

Le brouillon actuel de ce qu'on appelle C ++ 0x , il s'agit de < a href = "http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3092.pdf" rel = "noreferrer"> n3092 dit dans 7.2 Énumération déclarations , paragraphe 6:

  

Il est défini par l'implémentation qui   le type intégral est utilisé comme   type sous-jacent sauf que le   le type sous-jacent ne doit pas être plus grand   que int sauf si la valeur d'un   énumérateur ne peut pas tenir dans un int ou   non signé int.

Le même paragraphe dit aussi:

  

Si aucun type intégral ne peut tout représenter   les valeurs de l'énumérateur, l'énumération   est mal formé.

Mon interprétation de la partie à moins que la valeur d'un énumérateur ne puisse pas tenir dans un int ou un non signé est qu'il est parfaitement valide et sûr d'initialiser un énumérateur avec une valeur entière de 64 bits tant qu'il existe Type entier 64 bits fourni dans une implémentation C ++ particulière.

Par exemple:

enum MyEnum
{
    Undefined = 0xffffffffffffffffULL
};

Answer 4

Les réponses faisant référence à __ int64 ratent le problème. L’énumération est valide dans tous les compilateurs C ++ ayant un véritable type intégral 64 bits, c’est-à-dire tout compilateur C ++ 11 ou C ++ 03 avec les extensions appropriées. Les extensions C ++ 03 telles que __ int64 fonctionnent différemment d’un compilateur à l’autre, notamment en ce qu’elles conviennent comme type de base pour les énumérations.

Answer 5

Si le compilateur ne prend pas en charge les énumérations 64 bits avec des indicateurs de compilation ou tout autre moyen, je pense qu’il n’ya pas de solution à celui-ci.

Vous pouvez créer quelque chose comme dans votre exemple, quelque chose comme:

namespace MyNamespace {
const uint64 LARGE_VALUE = 0x1000000000000000;
};

et l'utiliser comme une énumération utilisant

MyNamespace::LARGE_VALUE 

ou

using MyNamespace;
....
val = LARGE_VALUE;

Answer 6

Puisque vous travaillez en C ++, une autre alternative pourrait être

const __int64 LARVE_VALUE = ...

Ceci peut être spécifié dans un fichier H.

Answer 7

votre fragment de code n'est pas standard c ++:

  

énumération MY_ENUM: non signé __int64

n'a pas de sens.

utilisez const __int64 à la place, comme le suggère Torlack

Answer 8

Le type enum est normalement déterminé par le type de données du premier initialiseur enum. Si la valeur doit dépasser la plage de ce type de données intégral, le compilateur c ++ s'assurera qu'il s'adapte en utilisant un type de données intégral plus grand. Si le compilateur découvre qu'il n'appartient à aucun type de données intégral, il générera une erreur. Réf.: http: //www.open-std .org / jtc1 / sc22 / wg21 / docs / papers / 2005 / n1905.pdf
Edit: Cependant, cela dépend uniquement de l'architecture de la machine

Answer 9

Une énumération en C ++ peut être n’importe quel type intégral. Vous pouvez, par exemple, avoir une énumération de caractères. IE:

enum MY_ENUM
{
   CHAR_VALUE = 'c',
};

Je supposerais que cela inclut __int64. Essayez juste

enum MY_ENUM
{
   LARGE_VALUE = 0x1000000000000000,
};

Selon mon commentateur, sixlettervariables, en C, le type de base sera toujours un int, tandis qu'en C ++, le type de base est celui qui est suffisamment grand pour contenir la plus grande valeur incluse. Donc, les deux énumérations ci-dessus devraient fonctionner.

Answer 10

Dans MSVC ++, vous pouvez procéder ainsi:

énumération MYLONGLONGENUM: __ int64 {BIG_KEY = 0x3034303232303330, ...};