Comment utiliser l'énumération dans le langage C

Lena Dupuy

Le programme ENUM dans le 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 les constantes intégrales nommées dans leurs programmes pour offrir une meilleure lisibilité et maintenabilité du logiciel. Cet article discutera en détail en détail.

Syntaxe

énumérer
Énumération_constant_element-1,
Énumération_constant_element-2,
Énumération_constant_element-3,
… ,
Énumération_constant_element-n,
;

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

Plongée profonde dans l'énumération

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

Erreur d'énumération
Io_error,
Disk_error,
Réseau_error
;

Le mot-clé «Enum» doit toujours être utilisé pour définir le type d'énumération. Donc, 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 d'énumération est toujours attribué la valeur 0, l'élémentation énumérée suivante se voit attribuer la valeur 1, et ainsi de suite.

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

Erreur d'énumération
Io_error = 2,
Disk_error,
Network_error = 8 ,
Print_error
;

Dans ce cas, l'io_error est explicitement affecté à une valeur de 2 par le programme 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 d'énumération (comme nous pouvons déclarer une variable de type entier)? Oui c'est le cas! Vous pouvez déclarer la variable d'énumération comme suit:

ENUM ERREUR HW_ERROR;

Encore une fois, «Enum» est le mot clé ici, «l'erreur» est le type d'énumération, et «hw_error» est une variable d'énumération.

Nous allons maintenant examiner les exemples suivants pour comprendre les différents usages de l'énumération:

Exemple 1: utilisation de la définition de l'énum par défaut
Exemple 2: utilisation de la définition de l'énume personnalisée
Exemple 3: Définition de l'énume en utilisant une expression constante
Exemple 4: Portée de l'énumération

Exemple 1: utilisation de la définition de l'énum par défaut

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

#inclure
/ * Définir le type d'énumération * /
Erreur d'énumération
Io_error,
Disk_error,
Réseau_error
;
int main()

ENUM ERREUR HW_ERROR; / * Création d'une variable d'énumération * /
printf ("Définition hw_error sur io_error \ n");
Hw_error = io_error;
printf ("valeur de hw_error =% d \ n", hw_error);
printf ("\ nseting hw_error à disk_error \ n");
Hw_error = disk_error;
printf ("valeur de hw_error =% d \ n", hw_error);
printf ("\ nseting hw_error vers network_error \ n");
Hw_error = réseau_error;
printf ("valeur de hw_error =% d \ n", hw_error);
retour 0;

Exemple 2: utilisation de la définition de l'énume 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 d'énumération (je.e., Io_error et network_error, respectivement), mais nous avons sauté l'initialisation explicite pour le 2^nd et 4^e éléments. Il est désormais de la responsabilité du compilateur d'attribuer les valeurs par défaut au 2^nd et 4^e Éléments d'énumération (je.e., Disk_error et print_error, respectivement). Disk_error sera attribué à une valeur de 3 et print_error sera attribué à une valeur de 9. Ci-dessous, vous verrez l'exemple de programme et la sortie.

#inclure
/ * Définissez le type d'énumération - Initialisation personnalisée * /
Erreur d'énumération
Io_error = 2,
Disk_error,
Network_error = 8,
Print_error
;
int main()

/ * Déclarer la variable d'énumération * /
ENUM ERREUR HW_ERROR;
printf ("Définition hw_error sur io_error \ n");
Hw_error = io_error;
printf ("valeur de hw_error =% d \ n", hw_error);
printf ("\ nseting hw_error à disk_error \ n");
Hw_error = disk_error;
printf ("valeur de hw_error =% d \ n", hw_error);
printf ("\ nseting hw_error vers network_error \ n");
Hw_error = réseau_error;
printf ("valeur de hw_error =% d \ n", hw_error);
printf ("\ nseting hw_error à print_error \ n");
Hw_error = print_error;
printf ("valeur de hw_error =% d \ n", hw_error);
retour 0;

Exemple 3: Définition de l'énume en utilisant une expression constante

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

#inclure
/ * Définissez le type d'énumération - Initialisation personnalisée en utilisant une expression constante
Une expression constante est utilisée ici dans le cas de:
un. Io_error et
b. Réseau_error
Il s'agit d'une manière inhabituelle de définir les éléments d'énumération; Cependant, ceci
Le programme démontre que cette façon d'éléments d'éléments d'initialisation est possible en C.
* /
Erreur d'énumération
Io_error = 1 + 2 * 3 + 4,
Disk_error,
Network_error = 2 == 2,
Print_error
;
int main()

/ * Déclarer la variable d'énumération * /
ENUM ERREUR HW_ERROR;
printf ("Définition hw_error sur io_error \ n");
Hw_error = io_error;
printf ("valeur de hw_error =% d \ n", hw_error);
printf ("\ nseting hw_error à disk_error \ n");
Hw_error = disk_error;
printf ("valeur de hw_error =% d \ n", hw_error);
printf ("\ nseting hw_error vers network_error \ n");
Hw_error = réseau_error;
printf ("valeur de hw_error =% d \ n", hw_error);
printf ("\ nseting hw_error à print_error \ n");
Hw_error = print_error;
printf ("valeur de hw_error =% d \ n", hw_error);
retour 0;

Exemple 4: Portée de l'énumération

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 la macro.

#inclure
int main()

/ * Définir le type d'énumération * /
enum error_1
Io_error = 10,
Disk_error,
Network_error = 3,
Print_error
;

/ * Définissez le type d'énumération dans la portée intérieure * /
enum error_1
Io_error = 20,
Disk_error,
Network_error = 35,
Print_error
;
/ * Déclarer la variable d'énumération * /
enum error_1 hw_error;
printf ("Définition hw_error sur io_error \ n");
Hw_error = io_error;
printf ("valeur de hw_error =% d \ n", hw_error);
printf ("\ nseting hw_error à disk_error \ n");
Hw_error = disk_error;
printf ("valeur de hw_error =% d \ n", hw_error);
printf ("\ nseting hw_error vers network_error \ n");
Hw_error = réseau_error;
printf ("valeur de hw_error =% d \ n", hw_error);
printf ("\ nseting hw_error à print_error \ n");
Hw_error = print_error;
printf ("valeur de hw_error =% d \ n", hw_error);

retour 0;

Comparaison entre enum et macro

Énumérer	Macro
La règle de portée est applicable à l'énumération.	La règle de portée n'est pas applicable à la macro.
L'attribution de valeur d'énumération par défaut se produit automatiquement. L'énuo 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 macro-constantes 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 tout en définissant 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 la macro au lieu d'une énumération. Cependant, les programmeurs expérimentés ont tendance à utiliser l'énum sur macro pour les projets de développement de logiciels à grande échelle. Cela aide à écrire des programmes propres et lisibles.

c Sharp

Comment utiliser l'héritage en C #

L'héritage permet à une classe de hériter des propriétés et des méthodes d'une autre classe. Il perm...

Mohamed Benoit

C programmation C

Que signifie '/ =' dans la programmation C?

L'opérateur «/ =» est un opérateur utile en programmation C qui effectue une division et une affecta...

Ines Dubois

Java

Exemples de servlet Java

Tutoriel sur les utilisations du servlet Java pour développer le serveur d'applications Web et les d...

Ethan Guillot