C Enumerations enum Declaration

Enums and Switch Statements

Enums pair well with switch because every named value can have a clear branch. This makes state-based code easier to read than scattered integer constants.

Use a default branch for defensive handling.
Keep enum names descriptive.
Review compiler warnings for missing cases when available.

Explicit Values and Protocols

Sometimes enum values must match external values such as HTTP-like codes, hardware registers, file formats, or network protocols. In those cases, assign explicit integers.

Use explicit values for external contracts.
Avoid changing enum numbers after data is stored.
Document values that come from a protocol.

Validation and String Conversion

C enums do not automatically validate values or convert names to strings. Add helper functions when user input, logs, or UI messages need readable names.

Validate integers before casting to enum.
Create enumToString helpers for logs.
Do not assume every int is a valid enum member.

Validate Enum Values at System Boundaries

An enum gives readable names to integer values, but C does not automatically reject every integer that is outside the declared enumerators. Data read from a file, packet, command line, or database must be checked before the program uses it as a valid state. Centralize conversion so logging, validation, and fallback behavior remain consistent.

Explicit values are important when another system stores or transmits the number. Once a value is public, reordering declarations must not change its meaning. Reserve unknown values where a protocol permits forward compatibility, and decide whether an unrecognized value should be rejected, preserved, or mapped to a safe fallback.

Use Bit Flags Separately from Exclusive States

A normal enum usually models one state selected from several alternatives. Independent options need powers-of-two bit flags so values can be combined with bitwise OR and tested with bitwise AND. Mixing sequential enumerators with flags creates combinations that are difficult to read and easy to validate incorrectly.

Do not assume an enum has a particular byte size unless the language version and implementation contract guarantee it. Use an explicitly sized integer in a binary format, then convert that integer to the enum after range checking.

Enum with Switch

#include <stdio.h>

enum Status {
    PENDING,
    PAID,
    CANCELLED
};

int main() {
    enum Status orderStatus = PAID;

    switch (orderStatus) {
        case PENDING: puts("Waiting for payment"); break;
        case PAID: puts("Ship the order"); break;
        case CANCELLED: puts("Do not process"); break;
    }
}

Explicit Enum Values

#include <stdio.h>

enum ErrorCode {
    OK = 0,
    NOT_FOUND = 404,
    SERVER_ERROR = 500
};

int main() {
    enum ErrorCode code = NOT_FOUND;
    printf("Code: %d\n", code);
}

Enum to String Helper

#include <stdio.h>

enum Status { PENDING, PAID, CANCELLED };

const char* statusName(enum Status status) {
    switch (status) {
        case PENDING: return "Pending";
        case PAID: return "Paid";
        case CANCELLED: return "Cancelled";
        default: return "Unknown";
    }
}

int main() {
    printf("%s\n", statusName(PAID));
}

Validate Integer Before Enum Use

#include <stdio.h>

enum Mode { READ = 1, WRITE = 2, EXECUTE = 3 };

int isValidMode(int value) {
    return value == READ || value == WRITE || value == EXECUTE;
}

int main() {
    int input = 2;
    if (isValidMode(input)) {
        enum Mode mode = (enum Mode) input;
        printf("Mode: %d\n", mode);
    }
}

Before you move on