C++ Unscoped Enumeration

// Standard unscoped enumeration (non-fixed underlying type)
enum Identifier {
    Enumerator1,
    Enumerator2 = ConstantExpression
};

// Unscoped enumeration with an explicit/fixed underlying type (C++11)
enum Identifier : IntegralType {
    Enumerator1,
    Enumerator2
};

// Opaque enum declaration / Forward declaration (C++11)
enum Identifier : IntegralType;

// Anonymous unscoped enumeration
enum {
    Enumerator1,
    Enumerator2
} optionalVariableList;

#include <cstdint>

// Opaque enum declaration (Forward declaration) requires a fixed underlying type
enum ForwardEnum : std::uint16_t;

// Standard unscoped enum (Implicit/non-fixed underlying type)
// Compiler will choose an underlying type no larger than 'int' here
enum Status {
    Pending,       // 0
    Active = 5,    // 5
    Suspended      // 6 (Active + 1)
};

// Explicit/fixed underlying type (C++11)
enum Flags : std::uint8_t {
    Read = 1,
    Write = 2,
    Execute = 4
};

// Anonymous enum with immediate variable declaration
enum { MaxRetries = 3 } retryConfig;

void demonstrateMechanics() {
    // Scope injection: Enumerators accessed without Status:: prefix
    Status currentStatus = Active; 
    
    // Implicit conversion for a fixed underlying type
    // Flags::Read converts directly to std::uint8_t first
    std::uint8_t numericFlag = Read; 
    
    // Implicit conversion for a non-fixed underlying type
    // Promotes to int (or larger if values exceeded int/unsigned int limits)
    int numericStatus = Suspended; 
    
    // Explicit cast required from integer to enum
    Status forcedStatus = static_cast<Status>(0); 
    
    // Anonymous enum injecting constants into the block scope
    enum { TimeoutMs = 5000 };
    int currentTimeout = TimeoutMs;

    // Declaring another variable of the anonymous enum type using decltype
    decltype(retryConfig) backupConfig = MaxRetries;
}

// Definition of the previously forward-declared enum
enum ForwardEnum : std::uint16_t {
    ValueA = 10,
    ValueB = 20
};