C Language
enumerazioni
Ricerca…
Osservazioni
Le enumerazioni sono costituite dalla parola chiave enum e da un identificativo facoltativo seguito da una lista di enumeratori racchiusa tra parentesi graffe.
Un identificatore è di tipo int .
L' elenco enumeratore ha almeno un elemento enumeratore .
Opzionalmente, un enumeratore può essere "assegnato" a un'espressione costante di tipo int .
Un enumeratore è costante ed è compatibile con un char , un intero con segno o un intero senza segno. Che mai usato è definito dall'implementazione . In ogni caso il tipo utilizzato dovrebbe essere in grado di rappresentare tutti i valori definiti per l'enumerazione in questione.
Se nessuna espressione costante è "assegnato" per un enumeratore ed è il 1 ° ingresso in un enumeratore-list prende valore 0 , altrimenti ottenere prende il valore della voce precedente nella enumeratore-list più 1.
L'utilizzo di più "assegnamenti" può portare a diversi enumeratori della stessa enumerazione con gli stessi valori.
Enumerazione semplice
Un'enumerazione è un tipo di dati definito dall'utente costituito da costanti integrali e a ciascuna costante integrale viene assegnato un nome. L'enumerazione delle parole enum viene utilizzata per definire il tipo di dati enumerati.
Se si utilizza enum anziché int o string/ char* , si aumenta il controllo in fase di compilazione e si evitano errori nel passaggio di costanti non valide e si documentano quali valori sono legali da utilizzare.
Esempio 1
enum color{ RED, GREEN, BLUE };
void printColor(enum color chosenColor)
{
const char *color_name = "Invalid color";
switch (chosenColor)
{
case RED:
color_name = "RED";
break;
case GREEN:
color_name = "GREEN";
break;
case BLUE:
color_name = "BLUE";
break;
}
printf("%s\n", color_name);
}
Con una funzione principale definita come segue (ad esempio):
int main(){
enum color chosenColor;
printf("Enter a number between 0 and 2");
scanf("%d", (int*)&chosenColor);
printColor(chosenColor);
return 0;
}
Esempio 2
(Questo esempio utilizza inizializzatori designati che sono standardizzati dal C99.)
enum week{ MON, TUE, WED, THU, FRI, SAT, SUN };
static const char* const dow[] = {
[MON] = "Mon", [TUE] = "Tue", [WED] = "Wed",
[THU] = "Thu", [FRI] = "Fri", [SAT] = "Sat", [SUN] = "Sun" };
void printDayOfWeek(enum week day)
{
printf("%s\n", dow[day]);
}
Lo stesso esempio usando il controllo del range:
enum week{ DOW_INVALID = -1,
MON, TUE, WED, THU, FRI, SAT, SUN,
DOW_MAX };
static const char* const dow[] = {
[MON] = "Mon", [TUE] = "Tue", [WED] = "Wed",
[THU] = "Thu", [FRI] = "Fri", [SAT] = "Sat", [SUN] = "Sun" };
void printDayOfWeek(enum week day)
{
assert(day > DOW_INVALID && day < DOW_MAX);
printf("%s\n", dow[day]);
}
Typedef enum
Ci sono diverse possibilità e convenzioni per nominare un'enumerazione. Il primo è usare un nome di tag subito dopo la parola chiave enum .
enum color
{
RED,
GREEN,
BLUE
};
Questa enumerazione deve quindi essere sempre utilizzata con la parola chiave e il tag in questo modo:
enum color chosenColor = RED;
Se usiamo typedef direttamente quando dichiariamo l' enum , possiamo omettere il nome del tag e quindi usare il tipo senza la parola chiave enum :
typedef enum
{
RED,
GREEN,
BLUE
} color;
color chosenColor = RED;
Ma in quest'ultimo caso non possiamo usarlo come enum color , perché non abbiamo usato il nome del tag nella definizione. Una convenzione comune è usare entrambi, in modo che lo stesso nome possa essere usato con o senza la parola chiave enum . Questo ha il particolare vantaggio di essere compatibile con C ++
enum color /* as in the first example */
{
RED,
GREEN,
BLUE
};
typedef enum color color; /* also a typedef of same identifier */
color chosenColor = RED;
enum color defaultColor = BLUE;
Funzione:
void printColor()
{
if (chosenColor == RED)
{
printf("RED\n");
}
else if (chosenColor == GREEN)
{
printf("GREEN\n");
}
else if (chosenColor == BLUE)
{
printf("BLUE\n");
}
}
Per ulteriori informazioni su typedef vedere Typedef
Enumerazione con valore duplicato
Un valore di enumerazioni non deve in alcun modo essere univoco:
#include <stdlib.h> /* for EXIT_SUCCESS */
#include <stdio.h> /* for printf() */
enum Dupes
{
Base, /* Takes 0 */
One, /* Takes Base + 1 */
Two, /* Takes One + 1 */
Negative = -1,
AnotherZero /* Takes Negative + 1 == 0, sigh */
};
int main(void)
{
printf("Base = %d\n", Base);
printf("One = %d\n", One);
printf("Two = %d\n", Two);
printf("Negative = %d\n", Negative);
printf("AnotherZero = %d\n", AnotherZero);
return EXIT_SUCCESS;
}
Il campione stampa:
Base = 0
One = 1
Two = 2
Negative = -1
AnotherZero = 0
costante di enumerazione senza nome tipografico
I tipi di enumerazione possono anche essere dichiarati senza dare loro un nome:
enum { buffersize = 256, };
static unsigned char buffer [buffersize] = { 0 };
Questo ci consente di definire costanti di tempo di compilazione di tipo int che possono essere usate come lunghezza di array come in questo esempio.