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:

• Tipo subjacente de um enum

• Enumerações gerenciados e padrão

• Operadores e enumerações

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