Enum Classes (Strongly Typed Enums)

In C, a standard enum is essentially a set of named integers. These names leak into the global scope (causing naming collisions) and implicitly convert to int (causing logical bugs).

In C++, enum class (also called a Scoped Enum) solves these issues.

1. Scoped: Enum values are local to the enum (accessed via EnumName::Value).
2. Strongly Typed: They do not implicitly convert to integer.
3. Fixed Size: You can explicitly define the underlying integer type (e.g., uint8_t) to save memory.

Syntax & Usage

1. Basic Declaration

// C-Style (Unsafe)
enum Color { RED, GREEN, BLUE }; 
// int x = RED; // ✅ Valid but dangerous

// C++ Style (Safe)
enum class Status { 
    OK, 
    ERROR, 
    BUSY 
};

// Status s = OK;          // ❌ Error: Unknown identifier 'OK'
Status s = Status::OK;     // ✅ Correct

2. Specifying Underlying Type (Crucial for Embedded)

You can force the enum to use a specific integer size instead of the compiler default (usually int / 4 bytes).

// Force use of 8-bit integer (1 byte)
enum class State : uint8_t {
    IDLE = 0,
    RUNNING = 1,
    FAULT = 2
};

// sizeof(State) is now guaranteed to be 1 byte.

Comparison: Old vs New

Relevance in Embedded/Firmware

1. Saving RAM & Flash

By defining enum class State : uint8_t, you ensure that variables of this type only consume 1 byte. Standard enums often default to 32-bit (4 bytes), wasting memory in struct layouts or arrays.

2. Preventing State Machine Bugs

In C, if you have enum Motor { OFF, ON } and enum LED { OFF, ON }, the compiler errors because OFF is defined twice.

With enum class Motor and enum class LED, Motor::OFF and LED::OFF are distinct. You can never accidentally assign a Motor state to an LED variable.

3. Switch-Case Safety

Modern compilers can warn you if a switch statement on an enum class does not handle all possible cases, ensuring you don't miss a new state added later.

Common Pitfalls (Practical Tips)