classe enum (Extensões de Componentes C++)
Declara uma enumeração, que é um tipo definido pelo usuário que consiste de um conjunto de constantes nomeadas chamadas enumeradores.
Todos os tempos de execução
Comentários
C++/CX e C++/CLI dão suporte a public enum class e a private enum class, que são semelhantes à classe enum do C++ padrão mas com a adição do especificador de acessibilidade.Para obter mais informações sobre a palavra-chave C++ padrão antiga, enum, consulte Declarações de enumeração de C++.
Tempo de Execução do Windows
Sintaxe
access enum class enumeration-identifier [:underlying-type] { enumerator-list } [var];
access enum struct enumeration-identifier [:underlying-type] { enumerator-list } [var];
Parâmetros
acessar
A acessibilidade da enumeração, que pode ser public ou private.identificador de enumeração
O nome da enumeração.tipo subjacente
(Opcional) O tipo subjacente da enumeração.(Opcional.somente Tempo de Execução do Windows) O tipo subjacente da enumeração, que pode ser bool, char, char16, int16, uint16, int, uint32, int64 ou uint64.
lista de enumeradores
Uma lista delimitada por vírgulas de nomes de enumerador.O valor de cada enumerador é uma expressão constante que é definido implicitamente pelo compilador ou explicitamente pela notação, enumerador=expressão constante.Por padrão, o valor do primeiro enumerador será zero se for definido implicitamente.O valor de cada enumerador definido implicitamente subsequente é o valor do enumerador anterior + 1.
var
(Opcional) O nome de uma variável do tipo enumeração.
Comentários
Para obter mais informações, e exemplos, consulte Enumerações.
Observe que o compilador emitirá mensagens de erro se a expressão constante que define o valor de um enumerador não puder ser representada pelo tipo subjacente.No entanto, o compilador não relata um erro para um valor que seja impróprio para o tipo subjacente.Por exemplo:
Se o tipo subjacente for numérico, e se um enumerador especificar o valor máximo para esse tipo, o valor da próxima enumeração definida implicitamente não poderá ser representado.
Se o tipo subjacente for bool, e se mais de dois enumeradores forem definidos implicitamente, os enumeradores após os dois primeiros não poderão ser representados.
Se o tipo subjacente for char16, e se o valor de enumeração variar de 0xD800 a 0xDFFF, o valor poderá ser representado.No entanto, o valor está logicamente incorreto porque representa metade de um par alternativo Unicode e não deve aparecer no isolamento.
Requisitos
Opção do compilador: /ZW
Common Language Runtime
Sintaxe
access enum class name [:type] { enumerator-list } var;
access enum struct name [:type] { enumerator-list } var;
Parâmetros
access
A acessibilidade do enumerador.Podem ser public ou private.enumerator-list
Uma lista separada por vírgulas de identificadores (enumeradores) na enumeração.name
O nome da enumeração.As enumerações gerenciadas anônimas não são permitidas.type (opcional)
O tipo subjacente dos identificadores.Isso pode ser qualquer tipo escalar, como as versões assinadas e não assinadas de int, short ou long.bool ou char também são permitidos.var (opcional)
O nome de uma variável do tipo enumeração.
Comentários
enum class e enum struct são declarações equivalentes.
Há dois tipos de enumerações: gerenciadas e padrão.
Uma enumeração gerenciada pode ser definida como a seguir,
enum class day {sun, mon };
e é equivalente semanticamente a:
ref class day {
public:
static const int sun = 0;
static const int mon = 1;
};
Uma enumeração padrão pode ser definida como a seguir:
enum day2 {sun, mon, };
e é equivalente semanticamente a:
static const int sun = 0;
static const int mon = 1;
Os nomes do enumerador gerenciador (identificadores) não são injetados no escopo onde a enumeração é definida; todas as referências a enumeradores devem ser totalmente qualificadas (nome::identificador).Por esse motivo, você não pode definir uma enumeração gerenciada anônima.
Os enumeradores de uma enumeração padrão são fortemente injetados no escopo delimitador.Isto é, se houver outro símbolo com o mesmo nome de um enumerador no escopo delimitador, o compilador gerará um erro.
No Visual C++ 2002 e no Visual C++ 2003, enumeradores foram injetados de forma fraca (visíveis no escopo delimitador a menos que houvesse outro identificador com o mesmo nome).
Se uma enumeração C++ padrão for definida (sem class ou struct), a compilação com /clr fará com que a enumeração seja compilada como uma enumeração gerenciada.A enumeração ainda tem a semântica de uma enumeração não gerenciada.Observe, o compilador injeta um atributo, Microsoft::VisualC::NativeEnumAttribute, que o compilador do Visual C++ reconhece, para identificar a intenção de um programador para que o enumerador seja um enumerador nativo.Outros compiladores simplesmente verão o enumeração padrão como uma enumeração gerenciada.
Uma enumeração nomeada padrão compilada com /clr estará visível no assembly como uma enumeração gerenciada e pode ser consumida por qualquer outro compilador gerenciado.No entanto, uma enumeração padrão sem nome não ficará publicamente visível a partir do assembly.
No Visual C++ 2002 e no Visual C++ 2003, uma enumeração padrão usada como o tipo em um parâmetro de função:
// mcppv2_enum.cpp
// compile with: /clr
enum E { a, b };
void f(E) {System::Console::WriteLine("hi");}
int main() {
E myi = b;
f(myi);
}
emitiria o seguinte no MSIL para a assinatura de função:
void f(int32);
No entanto, em versões atuais do compilador, a enumeração padrão é emitida como uma enumeração gerenciada com um [NativeEnumAttribute] e o seguinte no MSIL para a assinatura de função:
void f(E)
Para obter mais informações sobre enumerações nativas, consulte Declarações de enumeração C++.
No ambiente de desenvolvimento, você pode obter F1 ajuda para essas palavras-chave realçando a palavra-chave, (enum class, por exemplo) e pressionando F1.
Para obter mais informações sobre enumerações CLR, consulte:
Requisitos
Opção do compilador: /clr
Exemplos
Exemplo
decresc
// 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);
}Optionally, copy this sequence of tags for each example you want, then populate the text nodes. That is, after section+title("Examples")+content, insert: para+embeddedLabel ("Example")+para(sample description); code(sample); para+embeddedLabel("Output"); computerOutput(sample output, including 'br' tag instead of newlines)
Saída
Consulte também
Conceitos
Extensões de componente para plataformas de tempo de execução