classe di enumerazione (Estensioni del componente C++)
Dichiara un'enumerazione, che è un tipo definito dall'utente costituito da un insieme di costanti con un nome chiamate enumeratori.
Tutti i runtime
Note
C++/CX e C++/CLI supportano public enum class e private enum class che sono simili alla classe di enumerazione di C++ standard ma con l'aggiunta dell'identificatore di accessibilità.Per ulteriori informazioni sulla parola chiave enum del vecchio C++ standard, vedere la pagina Dichiarazioni di enumerazione C++.
Windows Runtime
Sintassi
access enum class enumeration-identifier [:underlying-type] { enumerator-list } [var];
access enum struct enumeration-identifier [:underlying-type] { enumerator-list } [var];
Parametri
access
L'accessibilità dell'enumerazione, che può essere public o private.enumeration-identifier
Il nome dell'enumerazione.underlying-type
(Facoltativo) Tipo sottostante dell'enumerazione.(Facoltativo.Solo Windows Runtime) Il tipo sottostante di un'enumerazione, che può essere bool, char, char16, int16, uint16, int, uint32, int64 o uint64.
enumerator-list
Elenco delimitato da virgole di nomi di enumeratore.Il valore di ogni enumeratore è un'espressione costante che viene definita in modo implicito dal compilatore, o in modo esplicito dalla notazione, enumerator=constant-expression.Per impostazione predefinita, il valore del primo enumeratore è zero se viene definito in modo implicito.Il valore di ogni enumeratore successivo definito in modo implicito è il valore dell'enumeratore precedente + 1.
var
(Facoltativo) Il nome di una variabile del tipo di enumerazione.
Note
Per ulteriori informazioni ed esempi, vedere la pagina relativa alle enumerazioni.
Si noti che il compilatore genera messaggi di errore se l'espressione costante che definisce il valore di un enumeratore non può essere rappresentata con l'underlying-type.Tuttavia, il compilatore non segnalerà un errore per un valore che non è appropriato per il tipo sottostante.Ad esempio:
Se underlying-type è numerico e un enumeratore specifica il valore massimo per quel tipo, il valore della prossima enumerazione definita in modo implicito non può essere rappresentato.
Se underlying-type è bool e se più di due enumeratori vengono definiti in modo implicito, gli enumeratori dopo i primi due non possono essere rappresentati.
Se underlying-type è char16 e il valore di enumerazione varia da 0xD800 a 0xDFFF, il valore può essere rappresentato.Tuttavia, il valore è errato perché rappresenta una coppia di surrogati Unicode e non deve essere visualizzato in modalità isolata.
.gif "a6cskb49.collapse_all(it-it,VS.110).gif")
Requisiti
Opzione del compilatore: /ZW
Common Language Runtime
Sintassi
access enum class name [:type] { enumerator-list } var;
access enum struct name [:type] { enumerator-list } var;
Parametri
access
L'accessibilità dell'enumerazione.Può essere public o private.enumerator-list
Un elenco delimitato da virgole di identificatori (enumeratori) nell'enumerazione.name
Il nome dell'enumerazione.Le enumerazioni gestite in modo anonimo non sono consentite.type (facoltativo)
Il tipo sottostante degli identificatori.Può essere un qualsiasi tipo scalare, ad esempio int, short, o long con o senza segno.Sono permessi anche bool o char.var (facoltativo)
Il nome di una variabile del tipo di enumerazione.
Note
Le dichiarazioni enum class e enum struct sono equivalenti.
Esistono due tipi di enumerazioni: gestite e standard.
Un'enumerazione gestita potrebbe essere definita come segue,
enum class day {sun, mon };
che è semanticamente equivalente a:
ref class day {
public:
static const int sun = 0;
static const int mon = 1;
};
Un'enumerazione standard potrebbe essere definita come segue:
enum day2 {sun, mon, };
che è semanticamente equivalente a:
static const int sun = 0;
static const int mon = 1;
I nomi gestiti dell'enumeratore (identificatori) non vengono inseriti nell'ambito dell'enumerazione che viene definita; tutti i riferimenti agli enumeratori devono essere completi (name::identificatore).Per questo motivo, non si possono definire enumerazioni gestite in modo anonimo.
Gli enumeratori di un'enumerazione standard vengono inseriti nell'ambito che li contiene.Ovvero se esiste un altro simbolo con lo stesso nome di un enumeratore nell'ambito che lo contiene, il compilatore genererà un errore.
In Visual C++ 2002 e Visual C++ 2003, gli enumeratori erano stati inseriti debolmente (erano visibili nell'ambito che li conteneva a meno che non fosse presente un identificatore con lo stesso nome).
Se un'enumerazione C++ standard viene definita (senza class o struct), allora la compilazione con /clr consente all'enumerazione di essere compilata come enumerazione gestita.L'enumerazione ha ancora la semantica di un'enumerazione non gestita.Si noti che il compilatore inserisce un attributo, Microsoft::VisualC::NativeEnumAttribute, che il compilatore di Visual C++ riconosce, per identificare l'intento del programmatore affinché l'enumerazione sia un'enumerazione nativa.Altri compilatori vedranno semplicemente l'enumerazione standard come una enumerazione gestita.
Un'enumerazione standard denominata che è stata compilata con /clr sarà visibile nell'assembly come un'enumerazione gestita e può essere utilizzata da qualsiasi altro compilatore gestito.Tuttavia, un'enumerazione standard senza nome non sarà visibile pubblicamente dall'assembly.
In Visual C++ 2002 e in Visual C++ 2003, un'enumerazione standard utilizzata come tipo di un parametro di una funzione:
// mcppv2_enum.cpp
// compile with: /clr
enum E { a, b };
void f(E) {System::Console::WriteLine("hi");}
int main() {
E myi = b;
f(myi);
}
produrrebbe il seguente codice MSIL per la firma della funzione:
void f(int32);
Tuttavia, nelle versioni correnti del compilatore, l'enumerazione standard viene generata come un'enumerazione gestita con [NativeEnumAttribute] e verrebbe prodotto il seguente MSIL per la firma della funzione:
void f(E)
Per ulteriori informazioni sulle enumerazioni native, vedere Dichiarazioni di enumerazioni C++.
Nell'ambiente di sviluppo, è possibile ottenere una guida su queste parole chiave evidenziando la parola chiave (ad esempio enum class) e premendo F1.
Per ulteriori informazioni sulle enumerazioni CLR, vedere:
Requisiti
Opzione del compilatore: /clr
Esempi
Esempio
desc
// 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)
Output