Comment utiliser enum en langage C

Le programme enum du langage de programmation C est utilisé pour définir des valeurs constantes intégrales, ce qui est très utile pour écrire des programmes propres et lisibles. Les programmeurs utilisent normalement l'énumération pour définir des constantes intégrales nommées dans leurs programmes afin d'améliorer la lisibilité et la maintenabilité du logiciel. Cet article discutera enum en détail.

Syntaxe

énumérer
Enumeration_Constant_Element-1,
Enumeration_Constant_Element-2,
Enumeration_Constant_Element-3,
… ,
Enumeration_Constant_Element-n,
;

La valeur par défaut de Enumeration_Constant_Element-1 est 0, la valeur de Enumeration_Constant_Element-2 est 1, la valeur de Enumeration_Constant_Element-3 est 2 et la valeur de Enumeration_Constant_Element-n est (n-1).

Plongez en profondeur dans Enum

Maintenant, puisque nous connaissons la syntaxe pour définir le type d'énumération, regardons un exemple :

Erreur enum
IO_ERROR,
DISK_ERROR,
NETWORK_ERROR
;

Le mot clé « enum » doit toujours être utilisé pour définir le type d'énumération. Ainsi, chaque fois que vous souhaitez définir un type d'énumération, vous devez utiliser le mot-clé "enum" avant . Après le mot-clé « enum », vous devez utiliser un identifiant valide pour définir le .

Dans l'exemple ci-dessus, le compilateur affectera IO_ERROR à la valeur intégrale : 0, DISK_ERROR à la valeur intégrale : 1 et NETWORK_ERROR à la valeur intégrale : 2. Par défaut, le premier élément enum reçoit toujours la valeur 0, le prochain élément enum reçoit la valeur 1, et ainsi de suite.

Ce comportement par défaut peut être modifié si nécessaire en affectant explicitement la valeur intégrale constante, comme suit :

enum erreur
IO_ERROR = 2,
DISK_ERROR,
ERREUR_RESEAU = 8 ,
PRINT_ERROR
;

Dans ce cas, IO_ERROR est explicitement affecté à une valeur de 2 par le programmeur, DISK_ERROR est affecté à une valeur de 3 par le compilateur, NETWORK_ERROR est explicitement affecté à la valeur de 8 par le programmeur, et PRINT_ERROR est affecté au prochain valeur intégrale de l'élément enum précédent NETWORK_ERROR (i.e., 9) par le compilateur.

Ainsi, vous comprenez maintenant comment définir un type d'énumération défini par l'utilisateur en C. Est-il possible de déclarer une variable de type enum (comme on peut déclarer une variable de type entier)? Oui c'est le cas! Vous pouvez déclarer la variable enum comme suit :

enum Erreur Hw_Error;

Encore une fois, "enum" est le mot-clé ici, "Error" est le type enum, et " Hw_Error" est une variable enum.

Nous allons maintenant regarder les exemples suivants pour comprendre les différents usages de enum :

Exemple 1 : Utilisation de la définition d'énumération par défaut
Exemple 2 : Utilisation de la définition d'énumération personnalisée
Exemple 3 : définition d'énumération à l'aide d'une expression constante
Exemple 4 : portée enum

Exemple 1 : Enum par défaut Définition Utilisation

Dans cet exemple, vous apprendrez à définir le type d'énumération avec des valeurs constantes par défaut. Le compilateur se chargera d'attribuer les valeurs par défaut aux éléments enum. Ci-dessous, vous verrez l'exemple de programme et la sortie correspondante.

#inclure
/* Définit le type d'énumération */
enum erreur
IO_ERROR,
DISK_ERROR,
NETWORK_ERROR
;
int main()

enum Erreur Hw_Error; /* Création d'une variable enum*/
printf("Définition de Hw_Error sur IO_ERROR\n");
Hw_Error = IO_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);
printf("\nDéfinition de Hw_Error sur DISK_ERROR\n");
Hw_Error = DISK_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);
printf("\nDéfinition de Hw_Error sur NETWORK_ERROR\n");
Hw_Error = NETWORK_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);
renvoie 0 ;

Exemple 2 : Utilisation de la définition d'énumération personnalisée

Dans cet exemple, vous apprendrez à définir le type d'énumération avec une valeur constante personnalisée. De plus, cet exemple vous aidera à comprendre comment l'initialisation des constantes personnalisées peut être effectuée dans n'importe quel ordre aléatoire. Dans cet exemple, nous avons explicitement défini la valeur constante pour le 1^st et 3^rd éléments enum (je.e., IO_ERROR et NETWORK_ERROR, respectivement), mais nous avons ignoré l'initialisation explicite pour le 2^sd et 4^e éléments. Il est maintenant de la responsabilité du compilateur d'affecter les valeurs par défaut aux 2^sd et 4^e éléments enum (je.e., DISK_ERROR et PRINT_ERROR, respectivement). DISK_ERROR sera affecté à une valeur de 3 et PRINT_ERROR sera affecté à une valeur de 9. Ci-dessous, vous verrez l'exemple de programme et la sortie.

#inclure
/* Définir le type d'énumération - Initialisation personnalisée*/
enum erreur
IO_ERROR = 2,
DISK_ERROR,
ERREUR_RESEAU = 8,
PRINT_ERROR
;
int main()

/* Déclarer la variable enum*/
enum Erreur Hw_Error;
printf("Définition de Hw_Error sur IO_ERROR\n");
Hw_Error = IO_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);
printf("\nDéfinition de Hw_Error sur DISK_ERROR\n");
Hw_Error = DISK_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);
printf("\nDéfinition de Hw_Error sur NETWORK_ERROR\n");
Hw_Error = NETWORK_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);
printf("\nDéfinition de Hw_Error sur PRINT_ERROR\n");
Hw_Error = PRINT_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);
renvoie 0 ;

Exemple 3 : définition d'énumération utilisant une expression constante

Dans cet exemple, vous apprendrez à utiliser l'expression constante pour définir la valeur constante des éléments enum.

#inclure
/* Définir le type d'énumération - initialisation personnalisée à l'aide d'une expression constante
l'expression constante est utilisée ici dans le cas de :
une. IO_ERROR et
b. NETWORK_ERROR
C'est une manière inhabituelle de définir les éléments enum ; cependant, ce
programme démontre que cette façon d'initialisation des éléments enum est possible en c.
*/
Erreur enum
IO_ERROR = 1 + 2 * 3 + 4,
DISK_ERROR,
ERREUR_RESEAU = 2 == 2,
PRINT_ERROR
;
int main()

/* Déclarer la variable enum*/
enum Erreur Hw_Error;
printf("Définition de Hw_Error sur IO_ERROR\n");
Hw_Error = IO_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);
printf("\nDéfinition de Hw_Error sur DISK_ERROR\n");
Hw_Error = DISK_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);
printf("\nDéfinition de Hw_Error sur NETWORK_ERROR\n");
Hw_Error = NETWORK_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);
printf("\nDéfinition de Hw_Error sur PRINT_ERROR\n");
Hw_Error = PRINT_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);
renvoie 0 ;

Exemple 4 : enum Portée

Dans cet exemple, vous apprendrez comment fonctionne la règle de portée pour enum. Une MACRO (#define) aurait pu être utilisée pour définir une constante au lieu de l'énumération, mais la règle de portée ne fonctionne pas pour MACRO.

#inclure
int main()

/* Définit le type d'énumération */
enum Erreur_1
IO_ERROR = 10,
DISK_ERROR,
ERREUR_RESEAU = 3,
PRINT_ERROR
;

/* Définit le type enum dans la portée interne*/
enum Erreur_1
IO_ERROR = 20,
DISK_ERROR,
ERREUR_RESEAU = 35,
PRINT_ERROR
;
/* Déclarer la variable enum*/
enum Error_1 Hw_Error;
printf("Définition de Hw_Error sur IO_ERROR\n");
Hw_Error = IO_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);
printf("\nDéfinition de Hw_Error sur DISK_ERROR\n");
Hw_Error = DISK_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);
printf("\nDéfinition de Hw_Error sur NETWORK_ERROR\n");
Hw_Error = NETWORK_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);
printf("\nDéfinition de Hw_Error sur PRINT_ERROR\n");
Hw_Error = PRINT_ERROR;
printf("Valeur de Hw_Error = %d \n",Hw_Error);

renvoie 0 ;

Comparaison entre enum et macro

Énumération

Macro

La règle de portée est applicable pour enum.

La règle de portée n'est pas applicable pour Macro.

L'affectation de la valeur Enum par défaut se produit automatiquement.

Enum est très utile pour définir un grand nombre de constantes. Le compilateur prend l'initialisation de valeur constante par défaut.

Les valeurs des constantes macro doivent toujours être mentionnées explicitement par le programmeur.

Cela pourrait être un processus fastidieux pour un grand nombre de constantes car le programmeur doit toujours définir manuellement chaque valeur constante lors de la définition de la macro.

Conclusion

Le programme enum en C pourrait être considéré comme une méthode facultative pour les programmes autonomes ou les projets de petite taille, car les programmeurs peuvent toujours utiliser une macro au lieu d'un enum. Cependant, les programmeurs expérimentés ont tendance à utiliser enum sur macro pour les projets de développement de logiciels à grande échelle. Cela aide à écrire des programmes propres et lisibles.