Syntaxe
énumérer <Nom du type d'énumération> {Enumeration_Constant_Element-1,
Enumeration_Constant_Element-2,
Enumeration_Constant_Element-3,
…… .........,
Enumeration_Constant_Element-m,
};
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 :
énumérerErreur{
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 fichier .
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 suivant enum-element 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 :
énumérerErreur{IO_ERROR= 2,
DISK_ERROR,
NETWORK_ERROR= 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 (c'est-à-dire 9) par le compilateur.
Alors, 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 :
énumérerErreur 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.
#comprendre/* Définit le type d'énumération */
énumérerErreur{
IO_ERROR,
DISK_ERROR,
NETWORK_ERROR
};
entierprincipale()
{
énumérerErreur Hw_Error; /* Création d'une variable enum*/
imprimer ('Définition de Hw_Error sur IO_ERROR ');
Hw_Error=IO_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
imprimer (' Définition de Hw_Error sur DISK_ERROR ');
Hw_Error=DISK_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
imprimer (' Définir Hw_Error sur NETWORK_ERROR ');
Hw_Error=NETWORK_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
revenir 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. En outre, 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 1stet 3rdenum éléments (c'est-à-dire, IO_ERROR et NETWORK_ERROR, respectivement), mais nous avons ignoré l'initialisation explicite pour les 2sdet 4eéléments. Il est maintenant de la responsabilité du compilateur d'affecter les valeurs par défaut aux 2sdet 4eéléments enum (c'est-à-dire, 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.
#comprendre/* Définir le type d'énumération - Initialisation personnalisée*/
énumérerErreur{
IO_ERROR= 2,
DISK_ERROR,
NETWORK_ERROR= 8,
PRINT_ERROR
};
entierprincipale()
{
/* Déclarer la variable enum*/
énumérerErreur Hw_Error;
imprimer ('Définition de Hw_Error sur IO_ERROR ');
Hw_Error=IO_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
imprimer (' Définition de Hw_Error sur DISK_ERROR ');
Hw_Error=DISK_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
imprimer (' Définir Hw_Error sur NETWORK_ERROR ');
Hw_Error=NETWORK_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
imprimer (' Définition de Hw_Error sur PRINT_ERROR ');
Hw_Error=PRINT_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
revenir 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.
#comprendre/* 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.
* /
énumérerErreur{
IO_ERROR= 1 + 2 * 3 + 4,
DISK_ERROR,
NETWORK_ERROR= 2 == 2,
PRINT_ERROR
};
entierprincipale()
{
/* Déclarer la variable enum*/
énumérerErreur Hw_Error;
imprimer ('Définition de Hw_Error sur IO_ERROR ');
Hw_Error=IO_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
imprimer (' Définition de Hw_Error sur DISK_ERROR ');
Hw_Error=DISK_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
imprimer (' Définir Hw_Error sur NETWORK_ERROR ');
Hw_Error=NETWORK_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
imprimer (' Définition de Hw_Error sur PRINT_ERROR ');
Hw_Error=PRINT_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
revenir 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.
#comprendreentierprincipale()
{
/* Définit le type d'énumération */
énumérerErreur_1{
IO_ERROR= dix,
DISK_ERROR,
NETWORK_ERROR= 3,
PRINT_ERROR
};
{
/* Définit le type enum dans la portée interne*/
énumérerErreur_1{
IO_ERROR= vingt,
DISK_ERROR,
NETWORK_ERROR= 35,
PRINT_ERROR
};
/* Déclarer la variable enum*/
énumérerErreur_1 Hw_Error;
imprimer ('Définition de Hw_Error sur IO_ERROR ');
Hw_Error=IO_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
imprimer (' Définition de Hw_Error sur DISK_ERROR ');
Hw_Error=DISK_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
imprimer (' Définir Hw_Error sur NETWORK_ERROR ');
Hw_Error=NETWORK_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
imprimer (' Définition de Hw_Error sur PRINT_ERROR ');
Hw_Error=PRINT_ERROR;
imprimer ('Valeur de Hw_Error = %d ',Hw_Error);
}
revenir 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 de constante lors de la définition de la macro. |
Conclusion
Le programme enum en C pourrait être considéré comme une méthode optionnelle 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.