Structures & Unions
Enumerations
Master C enumerations (enums) for defining named integer constants. Learn enum types, scoping, type safety, best practices, and how enums make code more readable and maintainable than magic numbers.
What Are Enumerations?
Enumerations define a set of named integer constants. Instead of using magic numbers like 0, 1, 2, you use meaningful names like MONDAY, TUESDAY, WEDNESDAY. Enums improve code readability, prevent errors, and make intent clear. They're essentially compile-time constants grouped under a type name.
C
#include <stdio.h>
/* Define enumeration */
enum Day {
SUNDAY, /* 0 */
MONDAY, /* 1 */
TUESDAY, /* 2 */
WEDNESDAY, /* 3 */
THURSDAY, /* 4 */
FRIDAY, /* 5 */
SATURDAY /* 6 */
};
int main(void) {
enum Day today = WEDNESDAY;
if (today == WEDNESDAY) {
printf("It's Wednesday!\n");
}
printf("Day value: %d\n", today); /* 3 */
/* Without enum (bad practice) */
int day = 3; /* What does 3 mean? */
/* With enum (clear meaning) */
enum Day better_day = WEDNESDAY; /* Clear! */
return 0;
}
/* Enums are compile-time constants */
enum Status {
ERROR = -1,
SUCCESS = 0,
PENDING = 1
};
/* Can be used in switch statements */
void check_status(enum Status status) {
switch (status) {
case ERROR:
printf("Error occurred\n");
break;
case SUCCESS:
printf("Success\n");
break;
case PENDING:
printf("Pending\n");
break;
}
}Enum Declaration and Values
Enum values start at 0 by default and increment. You can assign explicit values. Subsequent values continue from the last assigned value. Multiple enumerators can have the same value. Understanding these rules helps you design effective enumerations.
C
/* Default values (0, 1, 2, ...) */
enum Color {
RED, /* 0 */
GREEN, /* 1 */
BLUE /* 2 */
};
/* Explicit values */
enum Status {
ERROR = -1,
SUCCESS = 0,
WARNING = 1
};
/* Mixed explicit and implicit */
enum Priority {
LOW = 1,
MEDIUM, /* 2 (continues from LOW) */
HIGH, /* 3 */
CRITICAL = 10,
EMERGENCY /* 11 (continues from CRITICAL) */
};
/* Same value for multiple enumerators */
enum Boolean {
FALSE = 0,
NO = 0,
OFF = 0,
TRUE = 1,
YES = 1,
ON = 1
};
/* Using expressions */
enum Flags {
FLAG_NONE = 0,
FLAG_A = 1 << 0, /* 1 */
FLAG_B = 1 << 1, /* 2 */
FLAG_C = 1 << 2, /* 4 */
FLAG_D = 1 << 3 /* 8 */
};
/* Large values */
enum LargeValues {
SMALL = 1,
MEDIUM = 1000,
LARGE = 1000000,
HUGE = 1000000000
};
/* Typedef for convenience */
typedef enum {
NORTH,
SOUTH,
EAST,
WEST
} Direction;
Direction dir = NORTH; /* No need for 'enum' keyword */
/* Anonymous enum (just constants) */
enum {
MAX_BUFFER_SIZE = 1024,
MAX_CONNECTIONS = 100,
TIMEOUT_SECONDS = 30
};
/* Can use these constants directly */
char buffer[MAX_BUFFER_SIZE];
/* Print enum values */
void print_enum_values(void) {
printf("RED=%d, GREEN=%d, BLUE=%d\n", RED, GREEN, BLUE);
printf("FLAG_A=%d, FLAG_B=%d, FLAG_C=%d\n", FLAG_A, FLAG_B, FLAG_C);
}Enum Type Safety and Usage
In C, enums are just integers - no strict type checking. You can assign any integer to an enum variable, and enum values can be used as integers. This differs from C++ where enums are more type-safe. Understanding this helps you write safer enum code.
C
typedef enum {
STATE_INIT,
STATE_RUNNING,
STATE_PAUSED,
STATE_STOPPED
} State;
/* Enums are integers in C */
void type_safety_examples(void) {
State state = STATE_INIT;
/* Can assign int to enum (no error) */
state = 99; /* Compiles but probably wrong! */
/* Can assign enum to int */
int value = STATE_RUNNING; /* OK */
/* Can compare enums */
if (state == STATE_STOPPED) {
/* ... */
}
/* Enums in arithmetic */
state = STATE_INIT + 1; /* Results in STATE_RUNNING */
/* Type mismatch warning (but compiles) */
enum Color { RED, GREEN, BLUE } color;
State s = RED; /* Warning: different enum types */
}
/* Better: Use functions to validate */
int is_valid_state(State state) {
return state >= STATE_INIT && state <= STATE_STOPPED;
}
void set_state(State *current, State new_state) {
if (is_valid_state(new_state)) {
*current = new_state;
}
}
/* Switch statements with enums */
const char* state_to_string(State state) {
switch (state) {
case STATE_INIT: return "Init";
case STATE_RUNNING: return "Running";
case STATE_PAUSED: return "Paused";
case STATE_STOPPED: return "Stopped";
default: return "Unknown";
}
}
/* Compiler warnings for missing cases */
void handle_state(State state) {
switch (state) {
case STATE_INIT:
/* ... */
break;
case STATE_RUNNING:
/* ... */
break;
/* Missing STATE_PAUSED and STATE_STOPPED */
/* Some compilers warn about this */
}
}
/* Array indexed by enum */
const char* state_names[] = {
[STATE_INIT] = "Initialized",
[STATE_RUNNING] = "Running",
[STATE_PAUSED] = "Paused",
[STATE_STOPPED] = "Stopped"
};
void print_state(State state) {
if (is_valid_state(state)) {
printf("State: %s\n", state_names[state]);
}
}Enum Naming Conventions
Consistent naming makes enums more readable and prevents naming conflicts. Common conventions include prefixing enumerators with the enum name, using ALL_CAPS for constants, and grouping related enumerations.
C
/* Convention 1: Prefix with type name */
typedef enum {
COLOR_RED,
COLOR_GREEN,
COLOR_BLUE,
COLOR_YELLOW
} Color;
typedef enum {
STATE_INIT,
STATE_ACTIVE,
STATE_ERROR
} State;
/* Prevents conflicts */
Color color = COLOR_RED;
State state = STATE_INIT; /* No ambiguity */
/* Convention 2: Use singular for type, plural/descriptive for enum */
typedef enum FileMode {
FILE_MODE_READ,
FILE_MODE_WRITE,
FILE_MODE_APPEND
} FileMode;
/* Convention 3: Group related enums */
typedef enum {
HTTP_OK = 200,
HTTP_CREATED = 201,
HTTP_BAD_REQUEST = 400,
HTTP_NOT_FOUND = 404,
HTTP_SERVER_ERROR = 500
} HTTPStatus;
/* Convention 4: Use COUNT/MAX for size */
typedef enum {
DAY_SUNDAY,
DAY_MONDAY,
DAY_TUESDAY,
DAY_WEDNESDAY,
DAY_THURSDAY,
DAY_FRIDAY,
DAY_SATURDAY,
DAY_COUNT /* Number of days */
} Day;
/* Use in array allocation */
const char* day_names[DAY_COUNT] = {
"Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday"
};
/* Convention 5: Use INVALID/NONE for invalid values */
typedef enum {
DIRECTION_NONE = -1,
DIRECTION_NORTH,
DIRECTION_SOUTH,
DIRECTION_EAST,
DIRECTION_WEST
} Direction;
/* Convention 6: Bit flags with FLAG_ prefix */
typedef enum {
FLAG_NONE = 0,
FLAG_READ = 1 << 0,
FLAG_WRITE = 1 << 1,
FLAG_EXECUTE = 1 << 2,
FLAG_ALL = FLAG_READ | FLAG_WRITE | FLAG_EXECUTE
} FilePermission;Practical Enum Applications
Enums excel at representing finite sets of values: states, modes, error codes, options. They replace magic numbers, improve switch statements, and make code self-documenting. Understanding common patterns helps you leverage enums effectively.
C
/* State machine */
typedef enum {
FSM_IDLE,
FSM_PROCESSING,
FSM_WAITING,
FSM_ERROR,
FSM_DONE
} FSMState;
typedef struct {
FSMState state;
int data;
} StateMachine;
void fsm_process(StateMachine *fsm) {
switch (fsm->state) {
case FSM_IDLE:
fsm->state = FSM_PROCESSING;
break;
case FSM_PROCESSING:
/* Do work */
fsm->state = FSM_DONE;
break;
case FSM_ERROR:
fsm->state = FSM_IDLE; /* Reset */
break;
case FSM_DONE:
/* Complete */
break;
case FSM_WAITING:
/* Wait for event */
break;
}
}
/* Error codes */
typedef enum {
ERR_NONE = 0,
ERR_FILE_NOT_FOUND,
ERR_PERMISSION_DENIED,
ERR_OUT_OF_MEMORY,
ERR_INVALID_INPUT,
ERR_NETWORK_ERROR
} ErrorCode;
const char* error_message(ErrorCode err) {
switch (err) {
case ERR_NONE: return "No error";
case ERR_FILE_NOT_FOUND: return "File not found";
case ERR_PERMISSION_DENIED: return "Permission denied";
case ERR_OUT_OF_MEMORY: return "Out of memory";
case ERR_INVALID_INPUT: return "Invalid input";
case ERR_NETWORK_ERROR: return "Network error";
default: return "Unknown error";
}
}
/* Log levels */
typedef enum {
LOG_TRACE,
LOG_DEBUG,
LOG_INFO,
LOG_WARNING,
LOG_ERROR,
LOG_FATAL
} LogLevel;
void log_message(LogLevel level, const char *msg) {
const char *level_str[] = {
"TRACE", "DEBUG", "INFO", "WARNING", "ERROR", "FATAL"
};
printf("[%s] %s\n", level_str[level], msg);
}
/* Menu options */
typedef enum {
MENU_NEW = 1,
MENU_OPEN,
MENU_SAVE,
MENU_EXIT
} MenuOption;
MenuOption get_menu_choice(void) {
int choice;
printf("1. New\n2. Open\n3. Save\n4. Exit\n");
scanf("%d", &choice);
return (MenuOption)choice;
}
/* Configuration options */
typedef enum {
CONFIG_MODE_AUTO,
CONFIG_MODE_MANUAL,
CONFIG_MODE_SEMI_AUTO
} ConfigMode;
typedef struct {
ConfigMode mode;
int timeout;
int retries;
} Config;
/* Bit flags for options */
typedef enum {
OPT_NONE = 0,
OPT_VERBOSE = 1 << 0,
OPT_RECURSIVE = 1 << 1,
OPT_FORCE = 1 << 2,
OPT_DEBUG = 1 << 3
} Option;
void process_options(unsigned int options) {
if (options & OPT_VERBOSE) {
printf("Verbose mode enabled\n");
}
if (options & OPT_RECURSIVE) {
printf("Recursive mode enabled\n");
}
if (options & OPT_FORCE) {
printf("Force mode enabled\n");
}
}
/* Usage */
void option_examples(void) {
unsigned int opts = OPT_VERBOSE | OPT_DEBUG;
process_options(opts);
}Enums vs #define Constants
Both enums and #define create named constants, but they have important differences. Enums are type-checked, visible to debuggers, and grouped. #define are preprocessor replacements with no type information. Choose based on your needs.
C
/* Using #define */
#define COLOR_RED 0
#define COLOR_GREEN 1
#define COLOR_BLUE 2
/* Using enum */
typedef enum {
COLOR2_RED,
COLOR2_GREEN,
COLOR2_BLUE
} Color2;
/* Comparison */
/* 1. Type safety */
/* #define: No type */
int color1 = COLOR_RED; /* Just an int */
int x = COLOR_RED + 100; /* Compiles fine */
/* enum: Has type (but weak in C) */
Color2 color2 = COLOR2_RED; /* enum Color2 */
/* 2. Debugging */
/* #define: Shows value in debugger (0, 1, 2) */
/* enum: Shows name in debugger (COLOR2_RED) */
/* 3. Scope */
/* #define: Global scope (namespace pollution) */
#define STATE 1
/* enum: Can be scoped */
typedef enum {
MACHINE_STATE /* Less pollution */
} Machine;
/* 4. Grouping */
/* #define: Not grouped */
#define STATUS_OK 0
#define STATUS_ERROR 1
/* ... scattered throughout code */
/* enum: Grouped logically */
typedef enum {
STATUS2_OK,
STATUS2_ERROR
} Status2;
/* 5. Switch case coverage */
/* #define: No compiler warnings */
int status_def = COLOR_RED;
switch (status_def) {
case COLOR_RED: break;
/* Missing cases: no warning */
}
/* enum: May warn about missing cases */
Color2 status_enum = COLOR2_RED;
switch (status_enum) {
case COLOR2_RED: break;
/* Missing cases: compiler may warn */
}
/* 6. sizeof */
/* #define: Not applicable */
// sizeof(COLOR_RED); /* Error */
/* enum: Can get size */
sizeof(Color2); /* Size of enum type */
/* When to use each */
/* Use enum when:
- Defining related constants
- Want type information
- Need debugger support
- Want compiler warnings
- Values are sequential or related
*/
/* Use #define when:
- Single unrelated constants
- Need preprocessor features (#ifdef)
- Need string literals
- Traditional C style needed
- Working with bit operations
*/
/* Hybrid approach */
typedef enum {
MODE_A,
MODE_B,
MODE_C
} Mode;
#define DEFAULT_MODE MODE_A
#define MAX_MODE MODE_CSummary & What's Next
Key Takeaways:
- ✅ Enums define named integer constants
- ✅ Default values start at 0 and increment
- ✅ Can assign explicit values to enumerators
- ✅ Enums are just integers in C (weak typing)
- ✅ Use typedef for cleaner syntax
- ✅ Prefix enumerators to avoid naming conflicts
- ✅ Better than magic numbers for readability
- ✅ Prefer enums over #define for grouped constants