57. Mode Selection Enum
Declare a scoped enum class named Mode representing GPIO operating modes with exactly four values, defined in the following order:
InputOutputPullUpPullDown
The enum must use uint8_t as its underlying type.
Implement a function:
const char* toString(Mode m);
This function must return the following string representations:
Mode::Input→"INPUT"Mode::Output→"OUTPUT"Mode::PullUp→"PULLUP"Mode::PullDown→"PULLDOWN"
The program will read an integer value from standard input.
The input value is guaranteed to be in the range 0 to 3, where:
0maps toMode::Input1maps toMode::Output2maps toMode::PullUp3maps toMode::PullDown
After mapping the integer to the corresponding enum value, print the string representation using toString().
Input
A single integer value in the range 0 to 3 (inclusive).
Output
A single uppercase string representing the corresponding GPIO mode.
Example 1
Input:
0
Output:
INPUT
Example 2
Input:
2
Output:
PULLUP
Constraints
- Input integer
xis guaranteed to be in the range0 ≤ x ≤ 3 - Enum underlying type must be
uint8_t - No dynamic memory allocation is allowed
toString()must return string literals (nostd::string)- Program must compile under C++11 or later
- Execution must be deterministic with no undefined behavior
- Only standard headers
<iostream>and<cstdint>may be used
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.
- Scoped: Enum values are local to the enum (accessed via
EnumName::Value). - Strongly Typed: They do not implicitly convert to integer.
- 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; // ✅ Correct2. 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
| Feature | C-Style enum | C++ enum class |
|---|---|---|
| Scope | Leaks names to surrounding scope. | Namespaces names (Enum::Value). |
| Type Safety | Implicitly converts to int. | No implicit conversion. |
| Comparison | Can compare different enums (COLOR_RED == STATE_OFF). | Compile Error (Safe). |
| Size | Implementation defined (usually int). | User defined (default int). |
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)
| Pitfall | Details |
|---|---|
| ❌ Implicit Int Casting |
|
| ❌ Bitwise Flags | enum class does not support ` |
| ✅ Usage Rule | Use enum class for distinct states (State Machines, Error Codes). Use old enum or namespace constants for bitmasks. |
| ✅ Validating Inputs | Just because it's an enum class doesn't mean the value is valid.
|