enum (clase de C++/CLI y C++/CX)
Declara una enumeración en el ámbito de espacio de nombres, que es un tipo definido por el usuario que está compuesto de un conjunto de constantes con nombre llamadas enumeradores.
Todos los runtimes
Comentarios
C++/CX y C++/CLI admiten public enum class y private enum class que son similares a la enum class de C++ estándar pero con la adición del especificador de accesibilidad. En /clr, el tipo enum class de C++11 está permitido pero generará la advertencia C4472, que pretende garantizar que realmente desea el tipo de enumeración ISO y no el tipo C++/CX y C++/CLI. Para obtener más información sobre la palabra clave enum de C++ estándar de ISO, vea Enumeraciones.
Windows en tiempo de ejecución
Sintaxis
access
enum class
enumeration-identifier
[:underlying-type] { enumerator-list } [var];
accessenum structenumeration-identifier[:underlying-type] { enumerator-list } [var];
Parámetros
acceso
Accesibilidad de la enumeración, que puede ser public o private.
enumeration-identifier
Nombre de la enumeración.
underlying-type
(Opcional) Tipo de datos subyacente de la enumeración.
(Opcional. Solo Windows Runtime) Tipo subyacente de la enumeración, que puede ser bool, char, char16, int16, uint16, int, uint32, int64 o uint64.
enumerator-list
Lista de nombres de enumerador separados con comas.
El valor de cada enumerador es una expresión constante definida implícitamente por el compilador o explícitamente mediante la notación, enumerator=constant-expression. De forma predeterminada, el valor del primer enumerador es cero si se define implícitamente. El valor de cada enumerador implícitamente definido subsiguiente es el valor del enumerador anterior + 1.
var
(Opcional) Nombre de una variable del tipo de enumeración.
Comentarios
Para obtener más información y ejemplos, vea Enumeraciones.
Observe que el compilador emite mensajes de error si la expresión constante que define el valor de un enumerador no se puede representar mediante underlying-type. Sin embargo, el compilador no indica un error para un valor que es inadecuado para el tipo subyacente. Por ejemplo:
Si underlying-type es numérico y un enumerador especifica el valor máximo de ese tipo, el valor de la siguiente enumeración definida implícitamente no se puede representar.
Si underlying-type es
booly hay más de dos enumeradores definidos implícitamente, no se pueden representar los enumeradores después de los dos primeros.Si underlying-type es
char16y el valor de enumeración va de 0xD800 a 0xDFFF, el valor se puede representar. Sin embargo, el valor es lógicamente incorrecto porque representa la mitad del par suplente Unicode y no debe aparecer de forma aislada.
Requisitos
Opción del compilador: /ZW
Common Language Runtime
Sintaxis
access
enum class
name [:type] { enumerator-list } var;
accessenum structname [:type] { enumerator-list } var;
Parámetros
acceso
Accesibilidad de la enumeración. Puede ser public o private.
enumerator-list
Una lista delimitada por comas de los identificadores (enumeradores) en la enumeración.
name
Nombre de la enumeración. Las enumeraciones administradas anónimas no se permiten.
type
(Opcional) Tipo subyacente de los identificadores. Puede tratarse de cualquier tipo escalar, como versiones con signo o sin signo de int, short o long. También se permitebool o char .
var
(Opcional) Nombre de una variable del tipo de enumeración.
Comentarios
enum class y enum struct son declaraciones equivalentes.
Hay dos tipos de enumeraciones: administrada o C++/CX y estándar.
Una enumeración administrada o C++/CX puede definirse como sigue,
public enum class day {sun, mon };
y es semánticamente equivalente a:
ref class day {
public:
static const int sun = 0;
static const int mon = 1;
};
Una enumeración estándar puede definirse como sigue:
enum day2 { sun, mon };
y es semánticamente equivalente a:
static const int sun = 0;
static const int mon = 1;
Los nombres de enumerador administrados (identifiers) no se insertan en el ámbito en el que está definida la enumeración; todas las referencias a los enumeradores deben ser completas (name::identifier). Por esta razón, no se puede definir una enumeración administrada anónima.
Los enumeradores de una enumeración estándar se insertan fuertemente en el ámbito de inclusión. Es decir, si hay otro símbolo con el mismo nombre que un enumerador en el ámbito de inclusión, el compilador generará un error.
En Visual Studio 2002 y Visual Studio 2003, los enumeradores se insertaban de forma poco rigurosa (visibles en el ámbito de inclusión a menos que hubiera otro identificador con el mismo nombre).
Si se define una enumeración de C++ estándar (sin class o struct), la compilación con /clr hace que la enumeración se compile como una enumeración administrada. La enumeración todavía tiene la semántica de una enumeración no administrada. Nota: el compilador inserta un atributo, Microsoft::VisualC::NativeEnumAttribute, para identificar la intención del programador de que la enumeración sea una enumeración nativa. Otros compiladores verán simplemente la enumeración estándar como enumeración administrada.
Una enumeración estándar con nombre compilada con /clr estará visible en el ensamblado como una enumeración administrada y se puede usar en cualquier otro compilador administrado. Sin embargo, una enumeración estándar sin nombre no será visible de forma pública desde el ensamblado.
En Visual Studio 2002 y Visual Studio 2003, una enumeración estándar usada como el tipo de un parámetro de función:
// mcppv2_enum.cpp
// compile with: /clr
enum E { a, b };
void f(E) {System::Console::WriteLine("hi");}
int main() {
E myi = b;
f(myi);
}
emitiría lo siguiente en MSIL para la signatura de la función:
void f(int32);
Sin embargo, en las versiones actuales del compilador, la enumeración estándar se emite como enumeración administrada con [NativeEnumAttribute] y lo siguiente en MSIL para la signatura de la función:
void f(E)
Para obtener más información sobre enumeraciones nativas, vea Declaraciones de enumeración de C++.
Para obtener más información sobre las enumeraciones CLR, vea:
Requisitos
Opción del compilador: /clr
Ejemplos
// mcppv2_enum_2.cpp
// compile with: /clr
// managed enum
public enum class m { a, b };
// standard enum
public enum n { c, d };
// unnamed, standard enum
public enum { e, f } o;
int main()
{
// consume managed enum
m mym = m::b;
System::Console::WriteLine("no automatic conversion to int: {0}", mym);
System::Console::WriteLine("convert to int: {0}", (int)mym);
// consume standard enum
n myn = d;
System::Console::WriteLine(myn);
// consume standard, unnamed enum
o = f;
System::Console::WriteLine(o);
}
no automatic conversion to int: b
convert to int: 1
1
1