What are the definitions and usage techniques for enum types in C language?

What are the definitions and usage techniques for enum types in C language?

Enum Type Basics:

1. Basic Definition

   c
   enum Color {
       RED,
       GREEN,
       BLUE
   };
   
   enum Color c = RED;

2. Specifying Values

   c
   enum Status {
       SUCCESS = 0,
       ERROR = -1,
       PENDING = 1,
       COMPLETED = 2
   };

3. Anonymous Enums

   c
   enum {
       MAX_SIZE = 100,
       BUFFER_SIZE = 1024
   };

Advanced Usage:

1. Enums as Bit Flags

   c
   enum FileFlags {
       READ = 0x01,    // 0001
       WRITE = 0x02,   // 0010
       EXECUTE = 0x04, // 0100
       APPEND = 0x08   // 1000
   };
   
   unsigned int flags = READ | WRITE;
   if (flags & READ) {
       printf("Read permission\n");
   }

2. Enums with Switch

   c
   enum Day {
       MONDAY, TUESDAY, WEDNESDAY, 
       THURSDAY, FRIDAY, SATURDAY, SUNDAY
   };
   
   void print_day(enum Day day) {
       switch (day) {
           case MONDAY:
               printf("Monday\n");
               break;
           case TUESDAY:
               printf("Tuesday\n");
               break;
           default:
               printf("Other day\n");
       }
   }

3. Enum Type Conversion

   c
   enum Color { RED, GREEN, BLUE };
   
   // Enum to integer
   int value = RED;  // value = 0
   
   // Integer to enum
   enum Color c = (enum Color)1;  // GREEN
   
   // Enum size
   printf("Size of enum: %zu\n", sizeof(enum Color));

Best Practices:

1. Naming Conventions

   c
   // Use uppercase and underscores
   enum ErrorCode {
       ERROR_NONE,
       ERROR_INVALID_PARAM,
       ERROR_OUT_OF_MEMORY,
       ERROR_FILE_NOT_FOUND
   };
   
   // Or use prefixes
   enum SocketType {
       SOCK_TYPE_STREAM,
       SOCK_TYPE_DGRAM
   };

2. Enums as Array Indices

   c
   enum Month {
       JAN = 1, FEB, MAR, APR, MAY, JUN,
       JUL, AUG, SEP, OCT, NOV, DEC
   };
   
   const char* month_names[] = {
       "", "January", "February", "March", 
       "April", "May", "June", "July", 
       "August", "September", "October", 
       "November", "December"
   };
   
   printf("%s\n", month_names[JAN]);

3. Enums with typedef

   c
   typedef enum {
       STATE_IDLE,
       STATE_RUNNING,
       STATE_PAUSED,
       STATE_STOPPED
   } State;
   
   State current_state = STATE_IDLE;

Important Considerations:

1. Enum Value Continuity

   c
   enum Example {
       A = 1,
       B = 2,
       C = 5,  // Not continuous
       D = 6
   };
   // Cannot assume enum values are continuous

2. Enum Range

   c
   enum Small {
       MIN = 0,
       MAX = 255
   };
   
   // Compiler may choose larger type
   // Cannot guarantee only 1 byte

3. Enum Forward Declaration

   c
   // C11 supports
   enum Color;
   
   void process_color(enum Color c);
   
   enum Color {
       RED, GREEN, BLUE
   };

Practical Application Examples:

1. State Machine Implementation

   c
   typedef enum {
       STATE_INIT,
       STATE_CONNECTING,
       STATE_CONNECTED,
       STATE_DISCONNECTING,
       STATE_ERROR
   } ConnectionState;
   
   ConnectionState handle_state(ConnectionState state) {
       switch (state) {
           case STATE_INIT:
               return STATE_CONNECTING;
           case STATE_CONNECTING:
               return STATE_CONNECTED;
           case STATE_CONNECTED:
               return STATE_DISCONNECTING;
           default:
               return STATE_ERROR;
       }
   }

2. Configuration Options

   c
   enum ConfigOption {
       OPT_DEBUG = 0x01,
       OPT_VERBOSE = 0x02,
       OPT_LOG_FILE = 0x04,
       OPT_DAEMON = 0x08
   };
   
   void configure(unsigned int options) {
       if (options & OPT_DEBUG) {
           enable_debug();
       }
       if (options & OPT_DAEMON) {
           run_as_daemon();
       }
   }

3. Error Code Definition

   c
   enum LibraryError {
       LIB_OK = 0,
       LIB_ERR_INVALID_ARG = -1,
       LIB_ERR_OUT_OF_MEMORY = -2,
       LIB_ERR_IO = -3,
       LIB_ERR_TIMEOUT = -4
   };
   
   enum LibraryError library_init() {
       if (!allocate_memory()) {
           return LIB_ERR_OUT_OF_MEMORY;
       }
       return LIB_OK;
   }