c++ - name - use enum

Enum de 64 bits en C++?

Question

¿Hay alguna forma de tener una enumeración de 64 bits en C ++? Mientras refactorizaba algunos códigos, me encontré con un montón de #defines que sería mejor como una enumeración, pero al tener más de 32 bits causaba errores en el compilador.

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

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

Answer 1

C ++ 11 lo admite, usando esta sintaxis:

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

Answer 2

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

const __int64 LARVE_VALUE = ...

Esto se puede especificar en un archivo H.

Answer 3

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

Podrías crear algo así como en tu muestra algo así 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 4

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

enum MY_ENUM
{
   CHAR_VALUE = ''c'',
};

Supongo que esto incluye __int64. Prueba solo

enum MY_ENUM
{
   LARGE_VALUE = 0x1000000000000000,
};

De acuerdo con mi comentarista, sixlettervariables, en C, el tipo de base será siempre int, mientras que en C ++, el tipo de base es lo que sea lo suficientemente grande como para ajustarse al mayor valor incluido. Por lo tanto, ambas enumeraciones anteriores deberían funcionar.

Answer 5

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

enumeración MY_ENUM: unsigned __int64

no tiene sentido.

use const __int64 en su lugar, como sugiere Torlack

Answer 6

En MSVC ++ puedes hacer esto:

enum MYLONGLONGENUM: __ int64 {BIG_KEY = 0x3034303232303330, ...};

Answer 7

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

Está definido por implementación qué tipo integral se utiliza como el tipo subyacente excepto que el tipo subyacente no debe ser mayor que int a menos que el valor de un enumerador no pueda caber en una int o unsigned int.

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 una int int sin firmar es que es perfectamente válido y seguro inicializar el enumerador con un valor entero de 64 bits siempre que haya un tipo de entero de 64 bits proporcionado en un C ++ particular implementación.

Por ejemplo:

enum MyEnum
{
    Undefined = 0xffffffffffffffffULL
};

Answer 8

El tipo de Enum normalmente se determina por el tipo de datos del primer inicializador de enumeración. Si el valor excede el rango para ese tipo de datos integrales, el compilador de C ++ se asegurará de que se ajuste usando un tipo de datos integral más grande. Si el compilador encuentra que no pertenece a ninguno de los tipos de datos integrales, el compilador emitirá el error. Ref: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1905.pdf
Editar: Sin embargo, esto depende exclusivamente de la arquitectura de la máquina

Answer 9

Las respuestas que se refieren a __int64 pierden el problema. La enumeración es válida en todos los compiladores de C ++ que tienen un tipo integral verdadero de 64 bits, es decir, cualquier compilador de C ++ 11 o compiladores de C ++ 03 con las extensiones apropiadas. Las extensiones de C ++ 03 como __int64 funcionan de forma diferente en los compiladores, incluida su idoneidad como tipo base para las enumeraciones.

Answer 10

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

const __int64 LARGE_VALUE = 0x1000000000000000L;

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

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

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