L'énumération en C est également connue sous le nom de type énuméré. Il s'agit d'un type de données défini par l'utilisateur qui se compose de valeurs entières et qui fournit des noms significatifs à ces valeurs. L'utilisation d'énumération en C rend le programme facile à comprendre et à maintenir. L'énumération est définie à l'aide du mot-clé enum.
Voici la manière de définir l'énumération en C :
enum flag{integer_const1, integer_const2,.....integter_constN}; Dans la déclaration ci-dessus, nous définissons l'énumération nommée comme indicateur contenant 'N' constantes entières. La valeur par défaut de integer_const1 est 0, integer_const2 est 1, et ainsi de suite. On peut également changer la valeur par défaut des constantes entières au moment de la déclaration.
Par exemple:
enum fruits{mango, apple, strawberry, papaya}; La valeur par défaut de la mangue est 0, la pomme est 1, la fraise est 2 et la papaye est 3. Si nous voulons modifier ces valeurs par défaut, nous pouvons procéder comme indiqué ci-dessous :
enum fruits{ mango=2, apple=1, strawberry=5, papaya=7, }; Déclaration de type énuméré
Comme nous le savons, en langage C, nous devons déclarer la variable d'un type prédéfini tel que int, float, char, etc. De même, nous pouvons déclarer la variable d'un type de données défini par l'utilisateur, tel que enum. Voyons comment déclarer la variable d'un type enum.
Supposons que nous créions l'énumération de type status comme indiqué ci-dessous :
enum status{false,true}; Maintenant, nous créons la variable de type status :
enum status s; // creating a variable of the status type.
Dans l'instruction ci-dessus, nous avons déclaré la variable 's' de type status.
Pour créer une variable, les deux instructions ci-dessus peuvent être écrites sous la forme :
enum status{false,true} s; Dans ce cas, la valeur par défaut de false sera égale à 0 et la valeur de true sera égale à 1.
Créons un programme simple d'énumération.
#include enum weekdays{Sunday=1, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday}; int main() { enum weekdays w; // variable declaration of weekdays type w=Monday; // assigning value of Monday to w. printf('The value of w is %d',w); return 0; } Dans le code ci-dessus, nous créons un type d'énumération nommé weekdays et il contient le nom des sept jours. Nous avons attribué 1 valeur au dimanche et tous les autres noms recevront une valeur égale à la valeur précédente plus un.
Sortir
Montrons un autre exemple pour comprendre plus clairement l'énumération.
#include enum months{jan=1, feb, march, april, may, june, july, august, september, october, november, december}; int main() { // printing the values of months for(int i=jan;i<=december;i++) { printf('%d, ',i); } return 0; < pre> <p>In the above code, we have created a type of enum named as months which consists of all the names of months. We have assigned a '1' value, and all the other months will be given a value as the previous one plus one. Inside the main() method, we have defined a for loop in which we initialize the 'i' variable by jan, and this loop will iterate till December.</p> <p> <strong>Output</strong> </p> <img src="//techcodeview.com/img/c-tutorial/73/enum-c-2.webp" alt="Enum in C"> <h3>Why do we use enum?</h3> <p>The enum is used when we want our variable to have only a set of values. For example, we create a direction variable. As we know that four directions exist (North, South, East, West), so this direction variable will have four possible values. But the variable can hold only one value at a time. If we try to provide some different value to this variable, then it will throw the compilation error.</p> <p>The enum is also used in a switch case statement in which we pass the enum variable in a switch parenthesis. It ensures that the value of the case block should be defined in an enum.</p> <p> <strong>Let's see how we can use an enum in a switch case statement.</strong> </p> <pre> #include enum days{sunday=1, monday, tuesday, wednesday, thursday, friday, saturday}; int main() { enum days d; d=monday; switch(d) { case sunday: printf('Today is sunday'); break; case monday: printf('Today is monday'); break; case tuesday: printf('Today is tuesday'); break; case wednesday: printf('Today is wednesday'); break; case thursday: printf('Today is thursday'); break; case friday: printf('Today is friday'); break; case saturday: printf('Today is saturday'); break; } return 0; } </pre> <p> <strong>Output</strong> </p> <img src="//techcodeview.com/img/c-tutorial/73/enum-c-3.webp" alt="Enum in C"> <p> <strong>Some important points related to enum</strong> </p> <ul> <li>The enum names available in an enum type can have the same value. Let's look at the example.</li> </ul> <pre> #include int main(void) { enum fruits{mango = 1, strawberry=0, apple=1}; printf('The value of mango is %d', mango); printf('
The value of apple is %d', apple); return 0; } </pre> <p> <strong>Output</strong> </p> <img src="//techcodeview.com/img/c-tutorial/73/enum-c-4.webp" alt="Enum in C"> <ul> <li>If we do not provide any value to the enum names, then the compiler will automatically assign the default values to the enum names starting from 0.</li> <li>We can also provide the values to the enum name in any order, and the unassigned names will get the default value as the previous one plus one.</li> <li>The values assigned to the enum names must be integral constant, i.e., it should not be of other types such string, float, etc.</li> <li>All the enum names must be unique in their scope, i.e., if we define two enum having same scope, then these two enums should have different enum names otherwise compiler will throw an error.</li> </ul> <p> <strong>Let's understand this scenario through an example.</strong> </p> <pre> #include enum status{success, fail}; enum boolen{fail,pass}; int main(void) { printf('The value of success is %d', success); return 0; } </pre> <p> <strong>Output</strong> </p> <img src="//techcodeview.com/img/c-tutorial/73/enum-c-5.webp" alt="Enum in C"> <ul> <li>In enumeration, we can define an enumerated data type without the name also.</li> </ul> <pre> #include enum {success, fail} status; int main(void) { status=success; printf('The value of status is %d', status); return 0; } </pre> <p> <strong>Output</strong> </p> <img src="//techcodeview.com/img/c-tutorial/73/enum-c-6.webp" alt="Enum in C"> <h3>Enum vs. Macro in C</h3> <ul> <li>Macro can also be used to define the name constants, but in case of an enum, all the name constants can be grouped together in a single statement. <br> For example, <br> # define pass 0; <br> # define success 1; <br> The above two statements can be written in a single statement by using the enum type. <br> enum status{pass, success};</li> <li>The enum type follows the scope rules while macro does not follow the scope rules.</li> <li>In Enum, if we do not assign the values to the enum names, then the compiler will automatically assign the default value to the enum names. But, in the case of macro, the values need to be explicitly assigned.</li> <li>The type of enum in C is an integer, but the type of macro can be of any type.</li> </ul> <hr></=december;i++)> Sortir
Quelques points importants liés à l'énumération
- Les noms d'énumération disponibles dans un type enum peuvent avoir la même valeur. Regardons l'exemple.
#include int main(void) { enum fruits{mango = 1, strawberry=0, apple=1}; printf('The value of mango is %d', mango); printf('
The value of apple is %d', apple); return 0; } Sortir
- Si nous ne fournissons aucune valeur aux noms d'énumération, le compilateur attribuera automatiquement les valeurs par défaut aux noms d'énumération à partir de 0.
- Nous pouvons également fournir les valeurs du nom d'énumération dans n'importe quel ordre, et les noms non attribués obtiendront la valeur par défaut comme la précédente plus une.
- Les valeurs attribuées aux noms d'énumération doivent être des constantes intégrales, c'est-à-dire qu'elles ne doivent pas être d'autres types tels qu'une chaîne, un flottant, etc.
- Tous les noms d'énumération doivent être uniques dans leur portée, c'est-à-dire que si nous définissons deux énumérations ayant la même portée, alors ces deux énumérations doivent avoir des noms d'énumération différents, sinon le compilateur générera une erreur.
Comprenons ce scénario à travers un exemple.
#include enum status{success, fail}; enum boolen{fail,pass}; int main(void) { printf('The value of success is %d', success); return 0; } Sortir
- En énumération, nous pouvons également définir un type de données énuméré sans le nom.
#include enum {success, fail} status; int main(void) { status=success; printf('The value of status is %d', status); return 0; } Sortir
Enum vs Macro en C
- La macro peut également être utilisée pour définir les constantes de nom, mais dans le cas d'une énumération, toutes les constantes de nom peuvent être regroupées dans une seule instruction.
Par exemple,
# définit la passe 0 ;
# définir le succès 1 ;
Les deux instructions ci-dessus peuvent être écrites dans une seule instruction en utilisant le type enum.
enum status{réussite, succès} ; - Le type enum suit les règles de portée tandis que la macro ne suit pas les règles de portée.
- Dans Enum, si nous n'attribuons pas les valeurs aux noms d'énumération, le compilateur attribuera automatiquement la valeur par défaut aux noms d'énumération. Mais, dans le cas d’une macro, les valeurs doivent être explicitement attribuées.
- Le type d'énumération en C est un entier, mais le type de macro peut être de n'importe quel type.