¿Enumeración de 64 bits en C++?

Question

¿Hay alguna manera de tener una enumeración de 64 bits en C++?Mientras refactorizaba algo de código, encontré un montón de #defines que serían mejores como enumeración, pero tener más de 32 bits provoca un error en el compilador.

Por alguna razón pensé que lo siguiente podría funcionar:

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

Answer 1

No creo que eso sea posible con C++98.La representación subyacente de las enumeraciones depende del compilador.En ese caso, es mejor que utilices:

const __int64 LARGE_VALUE = 0x1000000000000000L;

A partir de C++ 11, es posible utilizar clases de enumeración para especificar el tipo base de la enumeración:

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

Además, las clases de enumeración introducen un nuevo alcance de nombre.Entonces, en lugar de referirse a LARGE_VALUE, harías referencia MY_ENUM::LARGE_VALUE.

Answer 2

C++ 11 admite esto, usando esta sintaxis:

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

Answer 3

El actual borrador del llamado C++0x, es n3092 dice en 7.2 Declaraciones de enumeración, apartado 6:

Está definido por la implementación qué tipo integral se usa como tipo subyacente, excepto que el tipo subyacente no será mayor que INT a menos que el valor de un enumerador no pueda caber en un int o no firmado.

El mismo párrafo también dice:

Si ningún tipo integral puede representar todos los valores del enumerador, la enumeración está mal formada.

Mi interpretación de la parte. a menos que el valor de un enumerador no pueda caber en un int o unsigned int es que es perfectamente válido y seguro inicializar el enumerador con un valor entero de 64 bits siempre que se proporcione un tipo entero de 64 bits en una implementación particular de C++.

Por ejemplo:

enum MyEnum
{
    Undefined = 0xffffffffffffffffULL
};

Answer 4

Las respuestas referidas a __int64 perder el problema.la enumeración es válido en todos los compiladores de C++ que tienen un verdadero tipo integral de 64 bits, es decircualquier compilador de C++ 11 o compiladores de C++ 03 con las extensiones adecuadas.Extensiones a C++03 como __int64 funciona de manera diferente entre compiladores, incluida su idoneidad como tipo base para enumeraciones.

Answer 5

Si el compilador no admite enumeraciones de 64 bits mediante indicadores de compilación o cualquier otro medio, creo que no hay solución para este problema.

Podrías crear algo como en tu muestra algo como:

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

y usarlo como una enumeración usando

MyNamespace::LARGE_VALUE 

o

using MyNamespace;
....
val = LARGE_VALUE;

Answer 6

Como estás trabajando en C++, otra alternativa podría ser

const __int64 LARVE_VALUE = ...

Esto se puede especificar en un archivo H.

Answer 7

su fragmento de código no es el estándar de C++:

enumeración MY_ENUM:sin firmar __int64

No tiene sentido.

use const __int64 en su lugar, como sugiere Torlack

Answer 8

El tipo de enumeración normalmente está determinado por el tipo de datos del primer inicializador de enumeración.Si el valor excede el rango para ese tipo de datos integral, entonces el compilador de C++ se asegurará de que encaje utilizando un tipo de datos integral más grande. Si el compilador descubre que no pertenece a ninguno de los tipos de datos integrales, arrojará un error.Árbitro: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1905.pdf
Editar:Sin embargo, esto depende puramente de la arquitectura de la máquina.

Answer 9

Una enumeración en C++ puede ser de cualquier tipo integral.Puedes, por ejemplo, tener una enumeración de caracteres.ES DECIR:

enum MY_ENUM
{
   CHAR_VALUE = 'c',
};

me gustaría asumir esto incluye __int64.Intenta solo

enum MY_ENUM
{
   LARGE_VALUE = 0x1000000000000000,
};

Según mi comentarista, variables de seis letras, en C el tipo base siempre será int, mientras que en C++ el tipo base es lo suficientemente grande como para caber en el valor incluido más grande.Entonces ambas enumeraciones anteriores deberían funcionar.

Answer 10

En MSVC++ puedes hacer esto:

enumeración MYLONGLONGENUM:__int64 { BIG_KEY=0x3034303232303330, ...};