C Language
Énumérations

Remarques

Énumération simple

Une énumération est un type de données défini par l'utilisateur constitué de constantes intégrales et chaque constante intégrale reçoit un nom. Le mot clé enum est utilisé pour définir le type de données énuméré.

Si vous utilisez enum au lieu de int ou string/ char* , vous augmentez la vérification au moment de la compilation et évitez les erreurs de transmission de constantes non valides, et vous documentez les valeurs légales à utiliser.

Exemple 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);
}

Avec une fonction principale définie comme suit (par exemple):

int main(){
    enum color chosenColor;
    printf("Enter a number between 0 and 2");
    scanf("%d", (int*)&chosenColor);
    printColor(chosenColor);
    return 0;
}

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]);
}

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

Il existe plusieurs possibilités et conventions pour nommer une énumération. La première consiste à utiliser un nom de tag juste après le mot-clé enum .

enum color
{ 
    RED, 
    GREEN, 
    BLUE 
};

Cette énumération doit alors toujours être utilisée avec le mot-clé et la balise comme ceci:

enum color chosenColor = RED;

Si nous utilisons directement typedef lors de la déclaration de l' enum , nous pouvons omettre le nom de la balise, puis utiliser le type sans le mot clé enum :

typedef enum 
{ 
    RED, 
    GREEN, 
    BLUE 
} color;

color chosenColor = RED;

Mais dans ce dernier cas, nous ne pouvons pas l'utiliser en tant que enum color , car nous n'avons pas utilisé le nom de tag dans la définition. Une convention courante consiste à utiliser les deux, de sorte que le même nom puisse être utilisé avec ou sans mot-clé enum . Cela présente l'avantage particulier d'être compatible avec 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;

Fonction:

void printColor()
{
    if (chosenColor == RED)
    {
        printf("RED\n");
    }
    else if (chosenColor == GREEN)
    {
        printf("GREEN\n");    
    }
    else if (chosenColor == BLUE)
    {
        printf("BLUE\n");
    }
}

Pour plus d'informations sur typedef voir Typedef

Enumération avec valeur en double

Une valeur d'énumération ne doit en aucun cas être unique:

#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;
}

L'échantillon imprime:

Base = 0
One = 1
Two = 2
Negative = -1
AnotherZero = 0

énumération constante sans nom de type

Les types d'énumération peuvent également être déclarés sans leur donner un nom:

  enum { buffersize = 256, };
  static unsigned char buffer [buffersize] = { 0 };

Cela nous permet de définir des constantes de temps de compilation de type int qui peuvent, comme dans cet exemple, être utilisées comme longueur de tableau.