Enum in C
Updated on 29th Dec, 23 9.1K Views

In this blog, you will learn what enumeration is and its implementation of code in the C programming language. This blog will guide you on when and how to use enumeration in C, including implementation in switch statements and flags. Further, we will be exploring the differences between enum and macro.

Table of Content

Learn the fundamentals of C by watching the video below:

What is Enum in C?

In C programming, an enum (enumeration) is a user-defined data type that is used to define a set of named integral constants; these constants are also known as enumerators. Enums allow you to create symbolic names (identifiers) that represent a set of values of different types, for example, integers, characters, floats, etc. 

Syntax for Declaring Enum in C

In C, you can declare an enumeration using the ’enum’ keyword, followed by the name of the enumeration and the list of constants inside curly braces. Here’s an example:

// Declaration of an enumeration named Color

enum Color {

    RED,

    GREEN,

    BLUE

};

In this example, RED, GREEN, and BLUE are constants within the ‘Color’ enumeration. By default, they are assigned values starting from 0 and incremented by 1 for each subsequent constant. You can also explicitly assign values to these constants as well. 

Let’s understand this with one example: 

// Enumeration with specially assigned values

enum Status {

    OK = 1,

    ERROR = -1,

    IN_PROGRESS = 0

};

In the above declaration, we have created an enumeration named Status where OK is assigned the value 1, ERROR is assigned -1, and IN_PROGRESS is assigned 0.

Learn C in detail with the C Programming Certification Course!

Enumerated Type Declaration to Create a Variable

In C, while declaring an enumeration, you can create variables of that enumerated type using the enum name that you have defined. Let’s understand this with one example:

// Declaration of an enumeration named Color

enum Color {

    RED,

    GREEN,

    BLUE

};

To create a variable of type Color, you just have to use the enum name followed by the variable name:

// Creating a variable of type Color

enum Color chosenColor; // This declares a variable named chosenColor of type Color

After declaring chosenColor of type Color, you can assign any value from the Color enumeration to it:

chosenColor = RED; // Assigning the value RED to chosenColor

This assigns the value RED from the Color enumeration to the variable chosenColor.

Take the first step to become a programming master with our C Programming Tutorial today!

Implementation of Enum in C Program

Let’s understand how we can implement the enumeration inside our code in the C language:

#include <stdio.h>

// Declaration of an enumeration named Color

enum Color {

    RED,

    GREEN,

    BLUE

};

int main() {

    // Creating a variable of type Color

    enum Color chosenColor = BLUE;

    // Using the enum variable in a simple conditional statement

    if(chosenColor == RED) {

        printf("The chosen color is Red.\n");

    } else if(chosenColor == GREEN) {

        printf("The chosen color is Green.\n");

    } else if(chosenColor == BLUE) {

        printf("The chosen color is Blue.\n");

    } else {

        printf("Unknown color.\n");

    }

    return 0;

}
output of enum program in CF

When to Use Enum in C

Enums in C are used to define a set of named integral constants that represent a set of related values. Here are some situations where enums are commonly used:

  • Improving Code Readability: Enums make code more readable by providing descriptive names for integral constants. For example, instead of using numeric values directly, you can use enum constants like RED, GREEN, and BLUE for colors, enhancing code readability and maintainability.
  • Switching Between States: Enums are commonly used in switch-case statements to execute different blocks of code based on the value of an enum variable. This usage is especially helpful when dealing with different states or options within a program.
  • APIs and Interfaces: Enums are useful while defining APIs or interfaces between different parts of a program. They provide a clear and structured way to communicate specific options or states between different modules or functions.
  • Flags and Bitmask Operations: Enums can also be used with bitwise operations to represent flags or bitmasks, where each enum constant represents a bit or a combination of bits of individual value.

Crack your next interview with the help of our C and Data structure interview Questions and Answers!

Utilizing Switch Statements with Enum

Switch statements are commonly used with enums in C to execute different blocks of code based on the value of an enum variable. Here’s an example that will help you understand the usage of switch statements with enums:

#include <stdio.h>

// Declaration of an enumeration named Day representing days of the week

enum Day {

    MONDAY,

    TUESDAY,

    WEDNESDAY,

    THURSDAY,

    FRIDAY,

    SATURDAY,

    SUNDAY

};

int main() {

    enum Day today = WEDNESDAY;

    switch(today) {

        case MONDAY:

            printf("It's Monday. Work mode ON!\n");

            break;

        case TUESDAY:

            printf("It's Tuesday. Keep up the pace!\n");

            break;

        case WEDNESDAY:

            printf("It's Wednesday. Halfway there!\n");

            break;

        case THURSDAY:

            printf("It's Thursday. Almost done!\n");

            break;

        case FRIDAY:

            printf("It's Friday. Weekend is coming!\n");

            break;

        case SATURDAY:

            printf("It's Saturday. Time to relax!\n");

            break;

        case SUNDAY:

            printf("It's Sunday. Prepare for the week ahead!\n");

            break;

        default:

            printf("Invalid day selected.\n");

    }

    return 0;

}
output of switch statement program using enum

In the above example, the enum ‘Day’ represents days of the week. The program initializes ‘today’ with the value ‘WEDNESDAY’ and uses a ‘switch’ statement to determine the day and print a message based on the value of ‘today’, which means depending on the value of the ‘today’ variable, the corresponding case block will be executed and will print a message for that day. If the value doesn’t match any case, the default block will be executed, and it will print “Invalid day selected.”

Using Enums for Flags

Enums are often used in C to create sets of flags or bitmasks by assigning different values to each constant that allow the combination of these values for various options or states. We can implement this by using bitwise operations to set, unset, or check multiple flags within a single integer variable. Here is an example demonstrating how enums can be used as flags:

#include <stdio.h>

// Declaration of an enumeration named Permissions as flags

enum Permissions {

    READ = 1,       // Binary: 0001

    WRITE = 2,      // Binary: 0010

    EXECUTE = 4     // Binary: 0100

};

int main() {

    // Creating a variable to hold multiple permissions

    enum Permissions userPermissions = READ | WRITE; // Binary: 0011 (READ | WRITE)

    // Checking for specific permissions using bitwise AND

    if (userPermissions & READ) {

        printf("User has READ permission.\n");

    }

    if (userPermissions & WRITE) {

        printf("User has WRITE permission.\n");

    }

    if (userPermissions & EXECUTE) {

        printf("User has EXECUTE permission.\n");

    } else {

        printf("User doesn't have EXECUTE permission.\n");

    }

    // Revoking a permission using bitwise NOT and AND

    userPermissions &= ~WRITE; // Removes WRITE permission

    printf("\nAfter revoking WRITE permission:\n");

    // Checking permissions after modification

    if (userPermissions & READ) {

        printf("User still has READ permission.\n");

    }

    if (userPermissions & WRITE) {

        printf("User still has WRITE permission.\n");

    } else {

        printf("User doesn't have WRITE permission anymore.\n");

    }

    if (userPermissions & EXECUTE) {

        printf("User has EXECUTE permission.\n");

    } else {

        printf("User doesn't have EXECUTE permission.\n");

    }

    return 0;

}
output of program of flag using enum in C

In this example, the ‘Permissions’ enum represents individual permissions as flags: ‘READ’, ‘WRITE’, and ‘EXECUTE’. Bitwise ‘OR’ (‘|’) is used to combine ‘READ’ and ‘WRITE’ permissions for the ‘userPermissions’ variable. Bitwise ‘AND’ (‘&’) is used to check if a specific permission is present, and bitwise NOT (‘~’) is used in combination with AND to revoke permission (WRITE, in this case).

Difference Between Enum and Macro

We use enums and macros for different purposes in C programming. Enums create symbolic names for related integral constants that give better readability, type safety, and values with scope in the enumeration. Enums are primarily used for defining a limited set of related options or states. On the other hand, macros are defined with ‘#define’ that perform text substitution globally, enabling versatile usage for constants but lacking in type safety and scoping. While enums enhance code clarity and maintainability by associating names with values, macros offer flexibility, but there are readability issues and unexpected behavior due to their direct textual replacement nature.

Example of Enum

#include <stdio.h>

// Declaration of an enumeration named Color

enum Color {

    RED,

    GREEN,

    BLUE

};

int main() {

    enum Color chosenColor = GREEN;

    switch(chosenColor) {

        case RED:

            printf("The chosen color is Red.\n");

            break;

        case GREEN:

            printf("The chosen color is Green.\n");

            break;

        case BLUE:

            printf("The chosen color is Blue.\n");

            break;

    }

    return 0;

}

Example of Macro : 

#include <stdio.h>

// Macro definition for maximum value

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int main() {

    int num1 = 10, num2 = 20;

    int maximum = MAX(num1, num2);

    printf("The maximum of %d and %d is %d\n", num1, num2, maximum);

    return 0;

}

In the above example, ‘enum Color’ defines symbolic constants for colors that are easy to read and type safely. The example of the functionality of macro defines ‘MAX(a, b)’ to find the maximum of two values. Macros perform text substitution directly by replacing ‘MAX(a, b)’ with the corresponding expression, but that does not provide type safety and scoped values.

In the enum case, ‘chosenColor’ is a variable of type ‘enum Color’ that can only hold the values ‘RED’, ‘GREEN’, or ‘BLUE’. Whereas the ‘MAX’ macro provides a flexible way to find the maximum value of any two inputs but doesn’t give type safety or scoping.

Conclusion

Enums in C provide a structured way to define named integral constants that enhance code readability, maintainability, and type safety. They associate symbolic names with related values, making the code more understandable. Unlike macros, enums offer scoped constants that reduce errors and improve code clarity, especially when defining a limited set of related options or states.

If you have any doubts, drop them on our C Community!

Course Schedule

Name Date Details
Python Course 02 Mar 2024(Sat-Sun) Weekend Batch
View Details
Python Course 09 Mar 2024(Sat-Sun) Weekend Batch
View Details
Python Course 16 Mar 2024(Sat-Sun) Weekend Batch
View Details

Leave a Reply

Your email address will not be published. Required fields are marked *

Speak to our course Advisor Now !

Subscribe to our newsletter

Signup for our weekly newsletter to get the latest news, updates and amazing offers delivered directly in your inbox.